celo-blockchain

diff --git go-ethereum/accounts/external/backend.go celo/accounts/external/backend.go index 7cdd82f8e5c0046df549dcdede91b98f90457d83..aee408e89f665bc6799fc482a6a503c7b506b491 100644 --- go-ethereum/accounts/external/backend.go +++ celo/accounts/external/backend.go @@ -17,10 +17,12 @@ package external   import ( + "crypto/ecdsa" "fmt" "math/big" "sync"   + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" @@ -148,12 +150,12 @@ func (api *ExternalSigner) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) { return accounts.Account{}, fmt.Errorf("operation not supported on external signers") }   -func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { - log.Error("operation SelfDerive not supported on external signers") +func (api *ExternalSigner) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return common.Address{}, fmt.Errorf("operation not supported on external signers") }   -func (api *ExternalSigner) signHash(account accounts.Account, hash []byte) ([]byte, error) { - return []byte{}, fmt.Errorf("operation not supported on external signers") +func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { + log.Error("operation SelfDerive not supported on external signers") }   // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed @@ -166,11 +168,14 @@ &signAddress, // Need to use the pointer here, because of how MarshalJSON is defined hexutil.Encode(data)); err != nil { return nil, err } - // If V is on 27/28-form, convert to 0/1 for Clique - if mimeType == accounts.MimetypeClique && (res[64] == 27 || res[64] == 28) { - res[64] -= 27 // Transform V from 27/28 to 0/1 for Clique use - } return res, nil +} + +// SignHash is not implemented for the external signer +// +// DEPRECATED, use SignData in future releases. +func (api *ExternalSigner) SignHash(account accounts.Account, hash []byte) ([]byte, error) { + panic("SignHash not implemented for the external signer") }   func (api *ExternalSigner) SignText(account accounts.Account, text []byte) ([]byte, error) { @@ -254,6 +259,26 @@ return nil, fmt.Errorf("password-operations not supported on external signers") } func (api *ExternalSigner) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) { return nil, fmt.Errorf("password-operations not supported on external signers") +} + +func (api *ExternalSigner) Decrypt(account accounts.Account, c, s1, s2 []byte) ([]byte, error) { + return nil, accounts.ErrNotSupported +} + +func (api *ExternalSigner) SignBLS(account accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + return blscrypto.SerializedSignature{}, accounts.ErrNotSupported +} + +func (api *ExternalSigner) GenerateProofOfPossession(account accounts.Account, address common.Address) ([]byte, []byte, error) { + return nil, nil, accounts.ErrNotSupported +} + +func (api *ExternalSigner) GenerateProofOfPossessionBLS(account accounts.Account, address common.Address) ([]byte, []byte, error) { + return nil, nil, accounts.ErrNotSupported +} + +func (api *ExternalSigner) GetPublicKey(account accounts.Account) (*ecdsa.PublicKey, error) { + return nil, accounts.ErrNotSupported }   func (api *ExternalSigner) listAccounts() ([]common.Address, error) {

diff --git go-ethereum/accounts/keystore/wallet.go celo/accounts/keystore/wallet.go index ef13d80d9fcd44cea222d9b7435b64b4dbcd9ecf..07fa8b434d2aed940bd49b471701435ebf7b4785 100644 --- go-ethereum/accounts/keystore/wallet.go +++ celo/accounts/keystore/wallet.go @@ -17,12 +17,17 @@ package keystore   import ( + "crypto/ecdsa" "math/big" + + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls"   "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" )   // keystoreWallet implements the accounts.Wallet interface for the original @@ -69,12 +74,32 @@ func (w *keystoreWallet) Contains(account accounts.Account) bool { return account.Address == w.account.Address && (account.URL == (accounts.URL{}) || account.URL == w.account.URL) }   +// Decrypt decrypts an ECIES ciphertext. +func (w *keystoreWallet) Decrypt(account accounts.Account, c, s1, s2 []byte) ([]byte, error) { + if account.Address != w.account.Address { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, accounts.ErrUnknownAccount + } + if account.URL != (accounts.URL{}) && account.URL != w.account.URL { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.Decrypt(account, c, s1, s2) +} + // Derive implements accounts.Wallet, but is a noop for plain wallets since there // is no notion of hierarchical account derivation for plain keystore accounts. func (w *keystoreWallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) { return accounts.Account{}, accounts.ErrNotSupported }   +// ConfirmAddress implements accounts.Wallet, but is a noop for plain wallets since there +// is no notion of address confirmation for plain keystore accounts. +func (w *keystoreWallet) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return common.Address{}, accounts.ErrNotSupported +} + // SelfDerive implements accounts.Wallet, but is a noop for plain wallets since // there is no notion of hierarchical account derivation for plain keystore accounts. func (w *keystoreWallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { @@ -87,21 +112,73 @@ // able to sign via our shared keystore backend). func (w *keystoreWallet) signHash(account accounts.Account, hash []byte) ([]byte, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign return w.keystore.SignHash(account, hash) }   +func (w *keystoreWallet) GetPublicKey(account accounts.Account) (*ecdsa.PublicKey, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the public key + return w.keystore.GetPublicKey(account) +} + +func (w *keystoreWallet) SignBLS(account accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return blscrypto.SerializedSignature{}, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.SignBLS(account, msg, extraData, useComposite, cip22) +} + +func (w *keystoreWallet) GenerateProofOfPossession(account accounts.Account, address common.Address) ([]byte, []byte, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.GenerateProofOfPossession(account, address) +} + +func (w *keystoreWallet) GenerateProofOfPossessionBLS(account accounts.Account, address common.Address) ([]byte, []byte, error) { + // Make sure the requested account is contained within + if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) + return nil, nil, accounts.ErrUnknownAccount + } + // Account seems valid, request the keystore to sign + return w.keystore.GenerateProofOfPossessionBLS(account, address) +} + // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed. func (w *keystoreWallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) { return w.signHash(account, crypto.Keccak256(data)) }   +// SignHash implements accounts.Wallet, attempting to sign the given hash with +// the given account. If the wallet does not wrap this particular account, an +// error is returned to avoid account leakage (even though in theory we may be +// able to sign via our shared keystore backend). +// +// DEPRECATED, use SignData in future releases. +func (w *keystoreWallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) { + return w.signHash(account, hash) +} + // SignDataWithPassphrase signs keccak256(data). The mimetype parameter describes the type of data being signed. func (w *keystoreWallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign @@ -132,6 +209,7 @@ // be able to sign via our shared keystore backend). func (w *keystoreWallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign @@ -143,6 +221,7 @@ // transaction with the given account using passphrase as extra authentication. func (w *keystoreWallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { // Make sure the requested account is contained within if !w.Contains(account) { + log.Debug(accounts.ErrUnknownAccount.Error(), "account", account) return nil, accounts.ErrUnknownAccount } // Account seems valid, request the keystore to sign

diff --git go-ethereum/accounts/keystore/key.go celo/accounts/keystore/key.go index c728765ddfe7fa8bf3f5b00c00c4783385e5aceb..f994af3e09af0a637e7a38d3f554d68c03294ece 100644 --- go-ethereum/accounts/keystore/key.go +++ celo/accounts/keystore/key.go @@ -66,6 +66,7 @@ }   type encryptedKeyJSONV3 struct { Address string `json:"address"` + BLSPublicKey string `json:"blspublickey"` Crypto CryptoJSON `json:"crypto"` Id string `json:"id"` Version int `json:"version"`

diff --git go-ethereum/accounts/keystore/passphrase.go celo/accounts/keystore/passphrase.go index db00ecf61584d629803ae9d5c033ca227cc2a013..77b863aa87f1c211bf03ad6fd12e95d3c5e6bd2b 100644 --- go-ethereum/accounts/keystore/passphrase.go +++ celo/accounts/keystore/passphrase.go @@ -38,6 +38,8 @@ "io/ioutil" "os" "path/filepath"   + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls" + "github.com/celo-org/celo-bls-go/bls" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -185,12 +187,32 @@ // EncryptKey encrypts a key using the specified scrypt parameters into a json // blob that can be decrypted later on. func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error) { keyBytes := math.PaddedBigBytes(key.PrivateKey.D, 32) + blsPrivateKeyBytes, err := blscrypto.ECDSAToBLS(key.PrivateKey) + if err != nil { + return nil, err + } + privateKey, err := bls.DeserializePrivateKey(blsPrivateKeyBytes) + if err != nil { + return nil, err + } + defer privateKey.Destroy() + publicKey, err := privateKey.ToPublic() + if err != nil { + return nil, err + } + defer publicKey.Destroy() + publicKeyBytes, err := publicKey.Serialize() + if err != nil { + return nil, err + } + cryptoStruct, err := EncryptDataV3(keyBytes, []byte(auth), scryptN, scryptP) if err != nil { return nil, err } encryptedKeyJSONV3 := encryptedKeyJSONV3{ hex.EncodeToString(key.Address[:]), + hex.EncodeToString(publicKeyBytes), cryptoStruct, key.Id.String(), version,

diff --git go-ethereum/accounts/keystore/keystore_test.go celo/accounts/keystore/keystore_test.go index e91862b9c4e1a494ce7c7d3f2cb0d931885d7afb..3f4a47b109757f7d1fd7a58ce3210acaea0b02c6 100644 --- go-ethereum/accounts/keystore/keystore_test.go +++ celo/accounts/keystore/keystore_test.go @@ -17,6 +17,7 @@ package keystore   import ( + "encoding/hex" "io/ioutil" "math/rand" "os" @@ -84,6 +85,27 @@ if err := ks.Unlock(a1, ""); err != nil { t.Fatal(err) } if _, err := ks.SignHash(accounts.Account{Address: a1.Address}, testSigData); err != nil { + t.Fatal(err) + } +} + +func TestComputeECDHSharedSecret(t *testing.T) { + keyHex := "044fb0a7e965176de5bbd615c5c9d5ca0927b74d914db881f7742362f2afda8a83b4e8e2cc87a98cdb5e2cf1c87b94a62ca9905de0e80676947166d4ae3d012691" + public := make([]byte, 65) + hex.Decode(public, []byte(keyHex)) + + dir, ks := tmpKeyStore(t, true) + defer os.RemoveAll(dir) + + pass := "" // not used but required by API + a1, err := ks.NewAccount(pass) + if err != nil { + t.Fatal(err) + } + if err := ks.Unlock(a1, ""); err != nil { + t.Fatal(err) + } + if _, err := ks.ComputeECDHSharedSecret(accounts.Account{Address: a1.Address}, public); err != nil { t.Fatal(err) } }

diff --git go-ethereum/accounts/keystore/keystore.go celo/accounts/keystore/keystore.go index 3f4b479583ca878e337028ca196fa97657a793b5..394262fbddf4e4f1618930b966757999009ce2dd 100644 --- go-ethereum/accounts/keystore/keystore.go +++ celo/accounts/keystore/keystore.go @@ -22,8 +22,10 @@ package keystore   import ( "crypto/ecdsa" + "crypto/elliptic" crand "crypto/rand" "errors" + "fmt" "math/big" "os" "path/filepath" @@ -32,11 +34,17 @@ "runtime" "sync" "time"   + //nolint:goimports + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls" + "github.com/celo-org/celo-bls-go/bls" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/ecies" "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/log" )   var ( @@ -234,6 +242,21 @@ func (ks *KeyStore) Accounts() []accounts.Account { return ks.cache.accounts() }   +// Decrypt decrypts an ECIES ciphertext. +func (ks *KeyStore) Decrypt(a accounts.Account, c, s1, s2 []byte) ([]byte, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, ErrLocked + } + // Import the ECDSA key as an ECIES key and decrypt the data. + eciesKey := ecies.ImportECDSA(unlockedKey.PrivateKey) + return eciesKey.Decrypt(c, s1, s2) +} + // Delete deletes the key matched by account if the passphrase is correct. // If the account contains no filename, the address must match a unique key. func (ks *KeyStore) Delete(a accounts.Account, passphrase string) error { @@ -273,6 +296,116 @@ // Sign the hash using plain ECDSA operations return crypto.Sign(hash, unlockedKey.PrivateKey) }   +func (ks *KeyStore) SignBLS(a accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return blscrypto.SerializedSignature{}, ErrLocked + } + + privateKeyBytes, err := blscrypto.ECDSAToBLS(unlockedKey.PrivateKey) + if err != nil { + return blscrypto.SerializedSignature{}, err + } + + privateKey, err := bls.DeserializePrivateKey(privateKeyBytes) + if err != nil { + return blscrypto.SerializedSignature{}, err + } + defer privateKey.Destroy() + + signature, err := privateKey.SignMessage(msg, extraData, useComposite, cip22) + if err != nil { + return blscrypto.SerializedSignature{}, err + } + defer signature.Destroy() + signatureBytes, err := signature.Serialize() + if err != nil { + return blscrypto.SerializedSignature{}, err + } + + return blscrypto.SerializedSignatureFromBytes(signatureBytes) +} + +func (ks *KeyStore) GenerateProofOfPossession(a accounts.Account, address common.Address) ([]byte, []byte, error) { + publicKey, err := ks.GetPublicKey(a) + if err != nil { + return nil, nil, err + } + publicKeyBytes := crypto.FromECDSAPub(publicKey) + + hash := crypto.Keccak256(address.Bytes()) + log.Info("msg", "msg", hexutil.Encode(hash)) + msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(hash), hash) + hash = crypto.Keccak256([]byte(msg)) + log.Info("hash", "hash", hexutil.Encode(hash)) + + signature, err := ks.SignHash(a, hash) + if err != nil { + return nil, nil, err + } + return publicKeyBytes, signature, nil +} + +func (ks *KeyStore) GenerateProofOfPossessionBLS(a accounts.Account, address common.Address) ([]byte, []byte, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, nil, ErrLocked + } + + privateKeyBytes, err := blscrypto.ECDSAToBLS(unlockedKey.PrivateKey) + if err != nil { + return nil, nil, err + } + + privateKey, err := bls.DeserializePrivateKey(privateKeyBytes) + if err != nil { + return nil, nil, err + } + defer privateKey.Destroy() + + signature, err := privateKey.SignPoP(address.Bytes()) + if err != nil { + return nil, nil, err + } + defer signature.Destroy() + signatureBytes, err := signature.Serialize() + if err != nil { + return nil, nil, err + } + + publicKey, err := privateKey.ToPublic() + if err != nil { + return nil, nil, err + } + defer publicKey.Destroy() + publicKeyBytes, err := publicKey.Serialize() + if err != nil { + return nil, nil, err + } + return publicKeyBytes, signatureBytes, nil +} + +// Retrieve the ECDSA public key for a given account. +func (ks *KeyStore) GetPublicKey(a accounts.Account) (*ecdsa.PublicKey, error) { + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, ErrLocked + } + return &unlockedKey.PrivateKey.PublicKey, nil +} + // SignTx signs the given transaction with the requested account. func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { // Look up the key to sign with and abort if it cannot be found @@ -505,3 +638,28 @@ for i := range b { b[i] = 0 } } + +// ComputeECDHSharedSecret computes an ECDH shared secret between the given account's +// private key and the public key provided. The account has to be unlocked first. +// The public key format is a 65 byte array, with byte[0] == 4, 32 bytes for X, +// and 32 bytes for Y (encoded in base256). +func (ks *KeyStore) ComputeECDHSharedSecret(a accounts.Account, public []byte) ([]byte, error) { + curve := crypto.S256() + // Look up the key to sign with and abort if it cannot be found + ks.mu.RLock() + defer ks.mu.RUnlock() + + unlockedKey, found := ks.unlocked[a.Address] + if !found { + return nil, ErrLocked + } + + var x, y *big.Int + x, y = elliptic.Unmarshal(curve, public) + if x == nil || y == nil { + return nil, errors.New("Could not unmarshal public key from bytes") + } + + shared, _ := crypto.S256().ScalarMult(x, y, unlockedKey.PrivateKey.D.Bytes()) + return shared.Bytes(), nil +}

diff --git go-ethereum/accounts/hd.go celo/accounts/hd.go index 23abd67c8dddd391e8e82b975eae706276b112cf..203bea39acbdf164860c7311d03cd47a8762c3e0 100644 --- go-ethereum/accounts/hd.go +++ celo/accounts/hd.go @@ -26,19 +26,19 @@ "strings" )   // DefaultRootDerivationPath is the root path to which custom derivation endpoints -// are appended. As such, the first account will be at m/44'/60'/0'/0, the second -// at m/44'/60'/0'/1, etc. -var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0} +// are appended. As such, the first account will be at m/44'/52752'/0'/0, the second +// at m/44'/52752'/0'/1, etc. +var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}   // DefaultBaseDerivationPath is the base path from which custom derivation endpoints -// are incremented. As such, the first account will be at m/44'/60'/0'/0/0, the second -// at m/44'/60'/0'/0/1, etc. -var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0} +// are incremented. As such, the first account will be at m/44'/52752'/0'/0/0, the second +// at m/44'/52752'/0'/0/1, etc. +var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0}   // LegacyLedgerBaseDerivationPath is the legacy base path from which custom derivation -// endpoints are incremented. As such, the first account will be at m/44'/60'/0'/0, the -// second at m/44'/60'/0'/1, etc. -var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0} +// endpoints are incremented. As such, the first account will be at m/44'/52752'/0'/0, the +// second at m/44'/52752'/0'/1, etc. +var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}   // DerivationPath represents the computer friendly version of a hierarchical // deterministic wallet account derivaion path. @@ -51,9 +51,9 @@ // // The BIP-44 spec https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki // defines that the `purpose` be 44' (or 0x8000002C) for crypto currencies, and // SLIP-44 https://github.com/satoshilabs/slips/blob/master/slip-0044.md assigns -// the `coin_type` 60' (or 0x8000003C) to Ethereum. +// the `coin_type` 52752' (or 0x8000CE10) to Celo. // -// The root path for Ethereum is m/44'/60'/0'/0 according to the specification +// The root path for Celo is m/44'/52752'/0'/0 according to the specification // from https://github.com/ethereum/EIPs/issues/84, albeit it's not set in stone // yet whether accounts should increment the last component or the children of // that. We will go with the simpler approach of incrementing the last component.

diff --git go-ethereum/accounts/hd_test.go celo/accounts/hd_test.go index 48f67eefb3001bb8a8b58ff29e3aec35e68ff06e..d7928fba3333499dbc7f2ad7ca161554b60c8dcd 100644 --- go-ethereum/accounts/hd_test.go +++ celo/accounts/hd_test.go @@ -30,43 +30,43 @@ input string output DerivationPath }{ // Plain absolute derivation paths - {"m/44'/60'/0'/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/44'/60'/0'/128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}}, - {"m/44'/60'/0'/0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, - {"m/44'/60'/0'/128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}}, - {"m/2147483692/2147483708/2147483648/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/2147483692/2147483708/2147483648/2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/44'/52752'/0'/0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/44'/52752'/0'/128", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 128}}, + {"m/44'/52752'/0'/0'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/44'/52752'/0'/128'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 128}}, + {"m/2147483692/2147536400/2147483648/0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/2147483692/2147536400/2147483648/2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}},   // Plain relative derivation paths - {"0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}}, - {"128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}}, - {"0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, - {"128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}}, - {"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0}}, + {"128", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 128}}, + {"0'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"128'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 128}}, + {"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}},   // Hexadecimal absolute derivation paths - {"m/0x2C'/0x3c'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/0x2C'/0x3c'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}}, - {"m/0x2C'/0x3c'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, - {"m/0x2C'/0x3c'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}}, - {"m/0x8000002C/0x8000003c/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, - {"m/0x8000002C/0x8000003c/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/0x2C'/0xce10'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/0x2C'/0xce10'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 128}}, + {"m/0x2C'/0xce10'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}}, + {"m/0x2C'/0xce10'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 128}}, + {"m/0x8000002C/0x8000ce10/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}}, + {"m/0x8000002C/0x8000ce10/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0x80000000 + 0}},   // Hexadecimal relative derivation paths - {"0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}}, - {"0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}}, - {"0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, - {"0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}}, - {"0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0}}, + {"0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 128}}, + {"0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}}, + {"0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 128}}, + {"0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0, 0x80000000 + 0}},   // Weird inputs just to ensure they work - {" m / 44 '\n/\n 60 \n\n\t' /\n0 ' /\t\t 0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}}, + {" m / 44 '\n/\n 52752 \n\n\t' /\n0 ' /\t\t 0", DerivationPath{0x80000000 + 44, 0x80000000 + 52752, 0x80000000 + 0, 0}},   // Invalid derivation paths {"", nil}, // Empty relative derivation path {"m", nil}, // Empty absolute derivation path {"m/", nil}, // Missing last derivation component - {"/44'/60'/0'/0", nil}, // Absolute path without m prefix, might be user error + {"/44'/52752'/0'/0", nil}, // Absolute path without m prefix, might be user error {"m/2147483648'", nil}, // Overflows 32 bit integer {"m/-1'", nil}, // Cannot contain negative number } @@ -91,28 +91,28 @@ func TestHdPathIteration(t *testing.T) { testDerive(t, DefaultIterator(DefaultBaseDerivationPath), []string{ - "m/44'/60'/0'/0/0", "m/44'/60'/0'/0/1", - "m/44'/60'/0'/0/2", "m/44'/60'/0'/0/3", - "m/44'/60'/0'/0/4", "m/44'/60'/0'/0/5", - "m/44'/60'/0'/0/6", "m/44'/60'/0'/0/7", - "m/44'/60'/0'/0/8", "m/44'/60'/0'/0/9", + "m/44'/52752'/0'/0/0", "m/44'/52752'/0'/0/1", + "m/44'/52752'/0'/0/2", "m/44'/52752'/0'/0/3", + "m/44'/52752'/0'/0/4", "m/44'/52752'/0'/0/5", + "m/44'/52752'/0'/0/6", "m/44'/52752'/0'/0/7", + "m/44'/52752'/0'/0/8", "m/44'/52752'/0'/0/9", })   testDerive(t, DefaultIterator(LegacyLedgerBaseDerivationPath), []string{ - "m/44'/60'/0'/0", "m/44'/60'/0'/1", - "m/44'/60'/0'/2", "m/44'/60'/0'/3", - "m/44'/60'/0'/4", "m/44'/60'/0'/5", - "m/44'/60'/0'/6", "m/44'/60'/0'/7", - "m/44'/60'/0'/8", "m/44'/60'/0'/9", + "m/44'/52752'/0'/0", "m/44'/52752'/0'/1", + "m/44'/52752'/0'/2", "m/44'/52752'/0'/3", + "m/44'/52752'/0'/4", "m/44'/52752'/0'/5", + "m/44'/52752'/0'/6", "m/44'/52752'/0'/7", + "m/44'/52752'/0'/8", "m/44'/52752'/0'/9", })   testDerive(t, LedgerLiveIterator(DefaultBaseDerivationPath), []string{ - "m/44'/60'/0'/0/0", "m/44'/60'/1'/0/0", - "m/44'/60'/2'/0/0", "m/44'/60'/3'/0/0", - "m/44'/60'/4'/0/0", "m/44'/60'/5'/0/0", - "m/44'/60'/6'/0/0", "m/44'/60'/7'/0/0", - "m/44'/60'/8'/0/0", "m/44'/60'/9'/0/0", + "m/44'/52752'/0'/0/0", "m/44'/52752'/1'/0/0", + "m/44'/52752'/2'/0/0", "m/44'/52752'/3'/0/0", + "m/44'/52752'/4'/0/0", "m/44'/52752'/5'/0/0", + "m/44'/52752'/6'/0/0", "m/44'/52752'/7'/0/0", + "m/44'/52752'/8'/0/0", "m/44'/52752'/9'/0/0", }) }

diff --git go-ethereum/accounts/usbwallet/ledger.go celo/accounts/usbwallet/ledger.go index c2caa39ad6a13cff12e8a65f77cccdb12bc34e6b..31bde56375b1437311a3136d87f294add45b5751 100644 --- go-ethereum/accounts/usbwallet/ledger.go +++ celo/accounts/usbwallet/ledger.go @@ -21,6 +21,7 @@ package usbwallet   import ( + "crypto/sha256" "encoding/binary" "encoding/hex" "errors" @@ -29,6 +30,7 @@ "io" "math/big"   "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/accounts/usbwallet/ledger" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" @@ -49,16 +51,26 @@ // specific opcodes. The same parameter values may be reused between opcodes. type ledgerParam2 byte   const ( - ledgerOpRetrieveAddress ledgerOpcode = 0x02 // Returns the public key and Ethereum address for a given BIP 32 path - ledgerOpSignTransaction ledgerOpcode = 0x04 // Signs an Ethereum transaction after having the user validate the parameters + ledgerOpRetrieveAddress ledgerOpcode = 0x02 // Returns the public key and Celo address for a given BIP 32 path + ledgerOpSignTransaction ledgerOpcode = 0x04 // Signs a Celo transaction after having the user validate the parameters ledgerOpGetConfiguration ledgerOpcode = 0x06 // Returns specific wallet application configuration - ledgerOpSignTypedMessage ledgerOpcode = 0x0c // Signs an Ethereum message following the EIP 712 specification + ledgerOpSignMessage ledgerOpcode = 0x08 // Signs a Celo message after having the user validate the parameters + ledgerOpProvideERC20 ledgerOpcode = 0x0A // Provides ERC20 information for tokens + + /* TODO: add functionality to the Ledger's Celo app + ledgerOpSignTypedMessage ledgerOpcode = 0x0c // Signs a Celo message following the EIP 712 specification + */   ledgerP1DirectlyFetchAddress ledgerParam1 = 0x00 // Return address directly from the wallet + ledgerP1ShowFetchAddress ledgerParam1 = 0x01 // Return address from the wallet after showing it + /* TODO: add functionality to the Ledger's Celo app ledgerP1InitTypedMessageData ledgerParam1 = 0x00 // First chunk of Typed Message data + */ ledgerP1InitTransactionData ledgerParam1 = 0x00 // First transaction data block for signing ledgerP1ContTransactionData ledgerParam1 = 0x80 // Subsequent transaction data block for signing ledgerP2DiscardAddressChainCode ledgerParam2 = 0x00 // Do not return the chain code along with the address + + statusCodeOK = 0x9000 )   // errLedgerReplyInvalidHeader is the error message returned by a Ledger data exchange @@ -69,6 +81,10 @@ // errLedgerInvalidVersionReply is the error message returned by a Ledger version retrieval // when a response does arrive, but it does not contain the expected data. var errLedgerInvalidVersionReply = errors.New("ledger: invalid version reply") + +// errLedgerBadStatusCode is the error message returned by any Ledger command +// when a response arrives with a bad status code. +var errLedgerBadStatusCode = errors.New("ledger: bad status code")   // ledgerDriver implements the communication with a Ledger hardware wallet. type ledgerDriver struct { @@ -77,6 +93,7 @@ version [3]byte // Current version of the Ledger firmware (zero if app is offline) browser bool // Flag whether the Ledger is in browser mode (reply channel mismatch) failure error // Any failure that would make the device unusable log log.Logger // Contextual logger to tag the ledger with its id + tokens *ledger.Tokens // Tokens list }   // newLedgerDriver creates a new instance of a Ledger USB protocol driver. @@ -93,15 +110,15 @@ if w.failure != nil { return fmt.Sprintf("Failed: %v", w.failure), w.failure } if w.browser { - return "Ethereum app in browser mode", w.failure + return "Celo app in browser mode", w.failure } if w.offline() { - return "Ethereum app offline", w.failure + return "Celo app offline", w.failure } - return fmt.Sprintf("Ethereum app v%d.%d.%d online", w.version[0], w.version[1], w.version[2]), w.failure + return fmt.Sprintf("Celo app v%d.%d.%d online", w.version[0], w.version[1], w.version[2]), w.failure }   -// offline returns whether the wallet and the Ethereum app is offline or not. +// offline returns whether the wallet and the Celo app is offline or not. // // The method assumes that the state lock is held! func (w *ledgerDriver) offline() bool { @@ -114,19 +131,38 @@ // parameter is silently discarded. func (w *ledgerDriver) Open(device io.ReadWriter, passphrase string) error { w.device, w.failure = device, nil   - _, err := w.ledgerDerive(accounts.DefaultBaseDerivationPath) + _, err := w.ledgerDerive(accounts.DefaultBaseDerivationPath, false) if err != nil { - // Ethereum app is not running or in browser mode, nothing more to do, return + // Celo app is not running or in browser mode, nothing more to do, return if err == errLedgerReplyInvalidHeader { w.browser = true } return nil } - // Try to resolve the Ethereum app's version, will fail prior to v1.0.2 + + // Try to resolve the Celo app's version if w.version, err = w.ledgerVersion(); err != nil { - w.version = [3]byte{1, 0, 0} // Assume worst case, can't verify if v1.0.0 or v1.0.1 + w.version = [3]byte{1, 0, 0} // Assume worst case + } + + /* + This is an example of how to enforce version numbers for features + + // Ensure the wallet is capable of signing the given transaction + if chainID != nil && w.version[0] <= 1 && w.version[1] == 0 && w.version[2] <= 2 { + return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2]) + } + */ + if w.tokens, err = ledger.LoadTokens(ledger.TokensBlob); err != nil { + return err } + return nil +} + +// ConfirmAddress implements usbwallet.driver, showing the address on the device. +func (w *ledgerDriver) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return w.ledgerDerive(path, true) }   // Close implements usbwallet.driver, cleaning up and metadata maintained within @@ -147,31 +183,39 @@ return nil }   // Derive implements usbwallet.driver, sending a derivation request to the Ledger -// and returning the Ethereum address located on that derivation path. +// and returning the Celo address located on that derivation path. func (w *ledgerDriver) Derive(path accounts.DerivationPath) (common.Address, error) { - return w.ledgerDerive(path) + return w.ledgerDerive(path, false) }   // SignTx implements usbwallet.driver, sending the transaction to the Ledger and // waiting for the user to confirm or deny the transaction. // -// Note, if the version of the Ethereum application running on the Ledger wallet is +// Note, if the version of the Celo application running on the Ledger wallet is // too old to sign EIP-155 transactions, but such is requested nonetheless, an error // will be returned opposed to silently signing in Homestead mode. func (w *ledgerDriver) SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) { - // If the Ethereum app doesn't run, abort + // If the Celo app doesn't run, abort if w.offline() { return common.Address{}, nil, accounts.ErrWalletClosed } - // Ensure the wallet is capable of signing the given transaction - if chainID != nil && w.version[0] <= 1 && w.version[1] <= 0 && w.version[2] <= 2 { - //lint:ignore ST1005 brand name displayed on the console - return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2]) + // All infos gathered and metadata checks out, request signing + return w.ledgerSign(path, tx, chainID) +} + +// SignPersonalMessage implements usbwallet.driver, sending the message to the Ledger and +// waiting for the user to confirm or deny the message. +func (w *ledgerDriver) SignPersonalMessage(path accounts.DerivationPath, message []byte) (common.Address, []byte, []byte, error) { + // If the Celo app doesn't run, abort + if w.offline() { + return common.Address{}, nil, nil, accounts.ErrWalletClosed } + // All infos gathered and metadata checks out, request signing - return w.ledgerSign(path, tx, chainID) + return w.ledgerSignData(path, message) }   +/* TODO: add functionality to the Ledger's Celo app // SignTypedMessage implements usbwallet.driver, sending the message to the Ledger and // waiting for the user to sign or deny the transaction. // @@ -189,6 +233,10 @@ } // All infos gathered and metadata checks out, request signing return w.ledgerSignTypedMessage(path, domainHash, messageHash) } +*/ +func (w *ledgerDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) { + return nil, accounts.ErrNotSupported +}   // ledgerVersion retrieves the current version of the Ethereum wallet app running // on the Ledger wallet. @@ -222,7 +270,7 @@ copy(version[:], reply[1:]) return version, nil }   -// ledgerDerive retrieves the currently active Ethereum address from a Ledger +// ledgerDerive retrieves the currently active Celo address from a Ledger // wallet at the specified derivation path. // // The address derivation protocol is defined as follows: @@ -250,10 +298,10 @@ // Description | Length // ------------------------+------------------- // Public Key length | 1 byte // Uncompressed Public Key | arbitrary -// Ethereum address length | 1 byte -// Ethereum address | 40 bytes hex ascii +// Celo address length | 1 byte +// Celo address | 40 bytes hex ascii // Chain code if requested | 32 bytes -func (w *ledgerDriver) ledgerDerive(derivationPath []uint32) (common.Address, error) { +func (w *ledgerDriver) ledgerDerive(derivationPath []uint32, showOnWallet bool) (common.Address, error) { // Flatten the derivation path into the Ledger request path := make([]byte, 1+4*len(derivationPath)) path[0] = byte(len(derivationPath)) @@ -261,7 +309,11 @@ for i, component := range derivationPath { binary.BigEndian.PutUint32(path[1+4*i:], component) } // Send the request and wait for the response - reply, err := w.ledgerExchange(ledgerOpRetrieveAddress, ledgerP1DirectlyFetchAddress, ledgerP2DiscardAddressChainCode, path) + p1 := ledgerP1DirectlyFetchAddress + if showOnWallet { + p1 = ledgerP1ShowFetchAddress + } + reply, err := w.ledgerExchange(ledgerOpRetrieveAddress, p1, ledgerP2DiscardAddressChainCode, path) if err != nil { return common.Address{}, err } @@ -271,13 +323,13 @@ return common.Address{}, errors.New("reply lacks public key entry") } reply = reply[1+int(reply[0]):]   - // Extract the Ethereum hex address string + // Extract the Celo hex address string if len(reply) < 1 || len(reply) < 1+int(reply[0]) { return common.Address{}, errors.New("reply lacks address entry") } hexstr := reply[1 : 1+int(reply[0])]   - // Decode the hex sting into an Ethereum address and return + // Decode the hex sting into an Celo address and return var address common.Address if _, err = hex.Decode(address[:], hexstr); err != nil { return common.Address{}, err @@ -326,17 +378,34 @@ path[0] = byte(len(derivationPath)) for i, component := range derivationPath { binary.BigEndian.PutUint32(path[1+4*i:], component) } - // Create the transaction RLP based on whether legacy or EIP155 signing was requested + var ( txrlp []byte err error ) + + if ledger.IsERC20Transfer(tx.Data()) { + err = w.ledgerProvideERC20(*tx.To(), chainID) + if err != nil && err != ledger.ErrCouldNotFindToken { + return common.Address{}, nil, err + } + + if tx.FeeCurrency() != nil { + err = w.ledgerProvideERC20(*tx.FeeCurrency(), chainID) + if err != nil && err != ledger.ErrCouldNotFindToken { + return common.Address{}, nil, err + } + } + } + + // Create the transaction RLP based on whether legacy or EIP155 signing was requested if chainID == nil { - if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data()}); err != nil { + //if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data()}); err != nil { + if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.FeeCurrency(), tx.GatewayFeeRecipient(), tx.GatewayFee(), tx.To(), tx.Value(), tx.Data()}); err != nil { return common.Address{}, nil, err } } else { - if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil { + if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.FeeCurrency(), tx.GatewayFeeRecipient(), tx.GatewayFee(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil { return common.Address{}, nil, err } } @@ -362,7 +431,7 @@ // Shift the payload and ensure subsequent chunks are marked as such payload = payload[chunk:] op = ledgerP1ContTransactionData } - // Extract the Ethereum signature and do a sanity validation + // Extract the Celo signature and do a sanity validation if len(reply) != crypto.SignatureLength { return common.Address{}, nil, errors.New("reply lacks signature") } @@ -387,6 +456,134 @@ } return sender, signed, nil }   +// ledgerProvideERC20 provides ERC20 information for tokens. +// +// The data protocol is defined as follows: +// +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+-----+--- +// E0 | 04 | 00: first data block +// 80: subsequent data block +// | 00 | variable | variable +// +// Where the input for the data block is: +// +// Description | Length +// -------------------------------------------------+---------- +// Ticker length | 1 byte +// Ticker | abitrary (< 10 bytes) +// Address | 20 bytes +// Decimals | 4 bytes +// ChainID | 4 bytes +// Signature | arbitrary +// +// And the output data is nothing. +func (w *ledgerDriver) ledgerProvideERC20(contractAddress common.Address, chainID *big.Int) error { + token, err := w.tokens.ByContractAddressAndChainID(contractAddress, chainID) + if err != nil { + return err + } + + _, err = w.ledgerExchange(ledgerOpProvideERC20, 0, 0, token.Data) + if err != nil { + return err + } + + return nil +} + +// ledgerSignData sends the message to the Ledger wallet, and waits for the user +// to confirm or deny the message. +// +// The message signing protocol is defined as follows: +// +// CLA | INS | P1 | P2 | Lc | Le +// ----+-----+----+----+-----+--- +// E0 | 08 | 00: first message data block +// 80: subsequent message data block +// | 00 | variable | variable +// +// Where the input for the first message block (first 255 bytes) is: +// +// Description | Length +// -------------------------------------------------+---------- +// Number of BIP 32 derivations to perform (max 10) | 1 byte +// First derivation index (big endian) | 4 bytes +// ... | 4 bytes +// Last derivation index (big endian) | 4 bytes +// data chunk | arbitrary +// +// And the input for subsequent message blocks (first 255 bytes) are: +// +// Description | Length +// ----------------------+---------- +// data chunk | arbitrary +// +// And the output data is: +// +// Description | Length +// ------------+--------- +// signature V | 1 byte +// signature R | 32 bytes +// signature S | 32 bytes +func (w *ledgerDriver) ledgerSignData(derivationPath []uint32, data []byte) (common.Address, []byte, []byte, error) { + hashMessage := sha256.Sum256(data) + w.log.Info("Signing message on Ledger with hash", "message", hex.EncodeToString(data), "hash", hex.EncodeToString(hashMessage[:])) + + // Flatten the derivation path into the Ledger request + path := make([]byte, 1+4*len(derivationPath)) + path[0] = byte(len(derivationPath)) + for i, component := range derivationPath { + binary.BigEndian.PutUint32(path[1+4*i:], component) + } + + dataLen := make([]byte, 4) + binary.BigEndian.PutUint32(dataLen, uint32(len(data))) + payload := append(path, dataLen...) + payload = append(payload, data...) + + // Send the request and wait for the response + var ( + op = ledgerP1InitTransactionData + reply []byte + err error + ) + for len(payload) > 0 { + // Calculate the size of the next data chunk + chunk := 255 + if chunk > len(payload) { + chunk = len(payload) + } + // Send the chunk over, ensuring it's processed correctly + reply, err = w.ledgerExchange(ledgerOpSignMessage, op, 0, payload[:chunk]) + if err != nil { + return common.Address{}, nil, nil, err + } + // Shift the payload and ensure subsequent chunks are marked as such + payload = payload[chunk:] + op = ledgerP1ContTransactionData + } + // Extract the Celo signature and do a sanity validation + if len(reply) != crypto.SignatureLength { + return common.Address{}, nil, nil, errors.New("reply lacks signature") + } + signature := append(reply[1:], reply[0]) + + msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data) + hash := crypto.Keccak256([]byte(msg)) + hashFixedLength := common.Hash{} + copy(hashFixedLength[:], hash) + + signer := new(types.HomesteadSigner) + addr, pubkey, err := signer.SenderData(hashFixedLength, signature) + if err != nil { + return common.Address{}, nil, nil, err + } + + return addr, pubkey, signature, nil +} + +/* TODO: add functionality to the Ledger's Celo app // ledgerSignTypedMessage sends the transaction to the Ledger wallet, and waits for the user // to confirm or deny the transaction. // @@ -448,6 +645,7 @@ } signature := append(reply[1:], reply[0]) return signature, nil } +*/   // ledgerExchange performs a data exchange with the Ledger wallet, sending it a // message and retrieving the response. @@ -543,6 +741,12 @@ } else { reply = append(reply, payload[:left]...) break } + } + + statusCodeBytes := reply[len(reply)-2:] + statusCode := int(binary.BigEndian.Uint16(statusCodeBytes)) + if statusCode != statusCodeOK { + return nil, errLedgerBadStatusCode } return reply[:len(reply)-2], nil }

diff --git go-ethereum/accounts/usbwallet/wallet.go celo/accounts/usbwallet/wallet.go index 86a9390a4694f83866d0272091977b1ec3b4b8f1..edc369eeda7231ac25e5d0e7aa56da12137ada41 100644 --- go-ethereum/accounts/usbwallet/wallet.go +++ celo/accounts/usbwallet/wallet.go @@ -19,11 +19,14 @@ package usbwallet   import ( "context" + "crypto/ecdsa" "fmt" "io" "math/big" "sync" "time" + + blscrypto "github.com/celo-org/celo-blockchain/crypto/bls"   "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts" @@ -53,6 +56,9 @@ // Open initializes access to a wallet instance. The passphrase parameter may // or may not be used by the implementation of a particular wallet instance. Open(device io.ReadWriter, passphrase string) error   + // ConfirmAddress shows the address of the given path on the wallet's display. + ConfirmAddress(path accounts.DerivationPath) (common.Address, error) + // Close releases any resources held by an open wallet instance. Close() error   @@ -67,6 +73,10 @@ // SignTx sends the transaction to the USB device and waits for the user to confirm // or deny the transaction. SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) + + // SignPersonalMessage sends the message to the USB device and waits for the user to confirm + // or deny the message. + SignPersonalMessage(path accounts.DerivationPath, message []byte) (common.Address, []byte, []byte, error)   SignTypedMessage(path accounts.DerivationPath, messageHash []byte, domainHash []byte) ([]byte, error) } @@ -451,6 +461,10 @@ _, exists := w.paths[account.Address] return exists }   +func (w *wallet) Decrypt(a accounts.Account, c, s1, s2 []byte) ([]byte, error) { + return nil, accounts.ErrNotSupported +} + // Derive implements accounts.Wallet, deriving a new account at the specific // derivation path. If pin is set to true, the account will be added to the list // of tracked accounts. @@ -491,6 +505,29 @@ } return account, nil }   +// ConfirmAddress implements accounts.Wallet, showing the address on the device. +func (w *wallet) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + // Try to derive the actual account and update its URL if successful + w.stateLock.RLock() // Avoid device disappearing during derivation + + if w.device == nil { + w.stateLock.RUnlock() + return common.Address{}, accounts.ErrWalletClosed + } + <-w.commsLock // Avoid concurrent hardware access + address, err := w.driver.ConfirmAddress(path) + w.commsLock <- struct{}{} + + w.stateLock.RUnlock() + + // If an error occurred or no pinning was requested, return + if err != nil { + return common.Address{}, err + } + + return address, nil +} + // SelfDerive sets a base account derivation path from which the wallet attempts // to discover non zero accounts and automatically add them to list of tracked // accounts. @@ -524,6 +561,62 @@ func (w *wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) { return nil, accounts.ErrNotSupported }   +func (w *wallet) GetPublicKey(account accounts.Account) (*ecdsa.PublicKey, error) { + return nil, accounts.ErrNotSupported +} + +func (w *wallet) SignBLS(account accounts.Account, msg []byte, extraData []byte, useComposite, cip22 bool) (blscrypto.SerializedSignature, error) { + return blscrypto.SerializedSignature{}, accounts.ErrNotSupported +} + +func (w *wallet) GenerateProofOfPossession(account accounts.Account, address common.Address) ([]byte, []byte, error) { + hash := crypto.Keccak256(address.Bytes()) + return w.signText(account, hash) +} + +func (w *wallet) signText(account accounts.Account, text []byte) ([]byte, []byte, error) { + w.stateLock.RLock() // Comms have own mutex, this is for the state fields + defer w.stateLock.RUnlock() + + // If the wallet is closed, abort + if w.device == nil { + return nil, nil, accounts.ErrWalletClosed + } + // Make sure the requested account is contained within + path, ok := w.paths[account.Address] + if !ok { + return nil, nil, accounts.ErrUnknownAccount + } + // All infos gathered and metadata checks out, request signing + <-w.commsLock + defer func() { w.commsLock <- struct{}{} }() + + // Ensure the device isn't screwed with while user confirmation is pending + // TODO(karalabe): remove if hotplug lands on Windows + w.hub.commsLock.Lock() + w.hub.commsPend++ + w.hub.commsLock.Unlock() + + defer func() { + w.hub.commsLock.Lock() + w.hub.commsPend-- + w.hub.commsLock.Unlock() + }() + // Sign the message and verify the sender to avoid hardware fault surprises + sender, pubkey, signed, err := w.driver.SignPersonalMessage(path, text) + if err != nil { + return nil, nil, err + } + if sender != account.Address { + return nil, nil, fmt.Errorf("signer mismatch: expected %s, got %s", account.Address.Hex(), sender.Hex()) + } + return pubkey, signed, nil +} + +func (w *wallet) GenerateProofOfPossessionBLS(account accounts.Account, address common.Address) ([]byte, []byte, error) { + return nil, nil, accounts.ErrNotSupported +} + // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed func (w *wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {   @@ -568,6 +661,16 @@ } return signature, nil }   +// SignHash implements accounts.Wallet, attempting to sign the given hash with +// the given account. If the wallet does not wrap this particular account, an +// error is returned to avoid account leakage (even though in theory we may be +// able to sign via our shared keystore backend). +// +// DEPRECATED, use SignData in future releases. +func (w *wallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) { + return w.signHash(account, hash) +} + // SignDataWithPassphrase implements accounts.Wallet, attempting to sign the given // data with the given account using passphrase as extra authentication. // Since USB wallets don't rely on passphrases, these are silently ignored. @@ -576,7 +679,8 @@ return w.SignData(account, mimeType, data) }   func (w *wallet) SignText(account accounts.Account, text []byte) ([]byte, error) { - return w.signHash(account, accounts.TextHash(text)) + _, signature, err := w.signText(account, text) + return signature, err }   // SignTx implements accounts.Wallet. It sends the transaction over to the Ledger @@ -629,7 +733,7 @@ // SignHashWithPassphrase implements accounts.Wallet, however signing arbitrary // data is not supported for Ledger wallets, so this method will always return // an error. func (w *wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) { - return w.SignText(account, accounts.TextHash(text)) + return w.SignText(account, text) }   // SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given

diff --git go-ethereum/accounts/usbwallet/trezor.go celo/accounts/usbwallet/trezor.go index a0f971f875e5256523dc3528fee0733f5e21788a..817df3c904ed7fddbd75993fe1bd9cb85d52547b 100644 --- go-ethereum/accounts/usbwallet/trezor.go +++ celo/accounts/usbwallet/trezor.go @@ -153,6 +153,11 @@ return nil }   +// ConfirmAddress implements usbwallet.driver, showing the address on the device. +func (w *trezorDriver) ConfirmAddress(path accounts.DerivationPath) (common.Address, error) { + return common.Address{}, accounts.ErrNotSupported +} + // Close implements usbwallet.driver, cleaning up and metadata maintained within // the Trezor driver. func (w *trezorDriver) Close() error { @@ -183,6 +188,12 @@ if w.device == nil { return common.Address{}, nil, accounts.ErrWalletClosed } return w.trezorSign(path, tx, chainID) +} + +// SignPersonalMessage implements usbwallet.driver, sending the message to the Trezor and +// waiting for the user to confirm or deny the message. +func (w *trezorDriver) SignPersonalMessage(path accounts.DerivationPath, message []byte) (common.Address, []byte, []byte, error) { + return common.Address{}, nil, nil, accounts.ErrNotSupported }   func (w *trezorDriver) SignTypedMessage(path accounts.DerivationPath, domainHash []byte, messageHash []byte) ([]byte, error) {

diff --git go-ethereum/accounts/usbwallet/ledger/tokens_test.go celo/accounts/usbwallet/ledger/tokens_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c8d9eb2a9863b075faf68b470c566a8cc17c315f --- /dev/null +++ celo/accounts/usbwallet/ledger/tokens_test.go @@ -0,0 +1,29 @@ +package ledger + +import ( + "encoding/hex" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" +) + +func TestCUSD(t *testing.T) { + tokens, _ := LoadTokens(TokensBlob) + cUSDAddress, _ := hex.DecodeString("765de816845861e75a25fca122bb6898b8b1282a") + var cUSDAddressFixedSize common.Address + copy(cUSDAddressFixedSize[:], cUSDAddress) + cUSDInfo, err := tokens.ByContractAddressAndChainID(cUSDAddressFixedSize, big.NewInt(42220)) + if err != nil { + t.Fatal("Could not find cUSD") + } + if cUSDInfo.Ticker != "cUSD" { + t.Fatalf("Ticker incorrect: %s", cUSDInfo.Ticker) + } + if cUSDInfo.Decimals != 18 { + t.Fatalf("Decimals incorrect: %d", cUSDInfo.Decimals) + } + if cUSDInfo.ChainID != 42220 { + t.Fatalf("ChainID incorrect: %d", cUSDInfo.ChainID) + } +}

diff --git go-ethereum/accounts/usbwallet/ledger/tokens_data.go celo/accounts/usbwallet/ledger/tokens_data.go new file mode 100644 index 0000000000000000000000000000000000000000..0d83eadb63c18d2fc6603278bed97d426d47f9a0 --- /dev/null +++ celo/accounts/usbwallet/ledger/tokens_data.go @@ -0,0 +1,3 @@ +package ledger + +const TokensBlob = "AAAAaARDRUxPRx7ON1DaI3+TuOM5xTaYm4l4pDgAAAASAACk7DBFAiEA5rECRg94+fCoIvoG9/5qWh62zl2C6Y+aFuuZrFe4CtcCIEJbRrkL3gqwT/Jj+7L3neazgpVCCTZZ3HX9JXXg5vleAAAAaARjVVNEdl3oFoRYYedaJfyhIrtomLixKCoAAAASAACk7DBFAiEApwQFHNBKXp+V2jq8BMD2y/5AwC9bhPQ2H4hT/vMl/B4CIFalOVtBFGREUKMU/F5vDlJLeQrTn6GQeDertpB2FpMvAAAAaARjRVVS2HY8uidqNzjm3oW0s79f3tbWynMAAAASAACk7DBFAiEAh2UeP1+SI2Ed5SiAjpJF6MkMrVa94gUwjJztyBlzhWMCIHfaOrEsxdxAGx+P+hxuSNO4zcw6KRLfJkkuic1V/CrHAAAAagZiIENFTE/dyb5X9VP+dXUtYWBrlMvX4CZO+AAAABIAAPNwMEUCIQCi62KsBfuNcfX0MriiRZ7a5DKERhtIz7sZ1SqBT7ruhgIgVrfmavyWzxzDW4AQeHn++A4qPjB1pQKoHvNXo8Hf1SMAAABpBmIgY1VTRGJJKmRKWI/ZBCcL7QatUrmr/qGuAAAAEgAA83AwRAIgGDYx4oB/gkYUqLeXqvEZXx9nOxVHzTe2ajyd2wnehxgCICQBe/rBPcXiaQJj3pdoXxroct/hV6r3G2G7y79EOEAPAAAAaQZiIGNFVVL57OMBJHrSziGJSUGDCiRw9Od0ygAAABIAAPNwMEQCIEdcFWP+HxEUoF1sCGVd34QGS0hL5cVUdrWdqVm3bYTgAiBCMA+Rg3Ubc3xla/35wzZesPlbeSMEPcr4uqL+8PeydwAAAGoGYSBDRUxP8ZSv31CwPmm9fQV8GqnhDJlU5MkAAAASAACu8zBFAiEAk/o0FBus2/QCrunFGEyoneQIRaMRC+y5L6Dvar8MU/kCIByJt2ziRhDG3AAbyXBIuJfZQujSHFcSJL3xF0xIlcPdAAAAaQZhIGNVU0SHQGn6HrFtRNYi8uDKJe6hcjabwQAAABIAAK7zMEQCIClrH2xgE3WMbD+hgQ7t5SiAcVG5WiUZ655voqCszKEoAiA/cO8UVgNY891MNJ5yeDk8w47WO0E1DQecrK71LR8g8gAAAGoGYSBjRVVSEMiSpuxDpT5F0LkWtLfTg7G3jA8AAAASAACu8zBFAiEAgpktbB1ZxyAwMJwKTSbZ30n8zgRuW0twbXoZxlsUAswCIHek4l4CIbjVMG2HVr0Ml9/8kA4F9dr69JBMaoSUkdKl" // #nosec

diff --git go-ethereum/accounts/usbwallet/ledger/tokens.go celo/accounts/usbwallet/ledger/tokens.go new file mode 100644 index 0000000000000000000000000000000000000000..e62d4aedd30d1c4a665209475f5f4e9c4f419f1d --- /dev/null +++ celo/accounts/usbwallet/ledger/tokens.go @@ -0,0 +1,101 @@ +package ledger + +import ( + "bytes" + "encoding/base64" + "encoding/binary" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +var ErrCouldNotFindToken = errors.New("could not find token") +var ErrNotAnERC20Transfer = errors.New("not an ERC20 transfer") + +type Token struct { + Ticker string + Address common.Address + Decimals uint32 + ChainID uint32 + Signature []byte + Data []byte +} + +type Tokens struct { + tokens []Token +} + +func LoadTokens(blob string) (*Tokens, error) { + buf, err := base64.StdEncoding.DecodeString(blob) + if err != nil { + return nil, err + } + + tokens := make([]Token, 0) + + i := 0 + for i < len(buf) { + length := int(binary.BigEndian.Uint32(buf[i : i+4])) + i += 4 + + item := buf[i : i+length] + offset := 0 + + tickerLength := int(item[offset]) + offset += 1 + + ticker := string(item[offset : offset+tickerLength]) + offset += tickerLength + + var address common.Address + copy(address[:], item[offset:offset+20]) + offset += 20 + + decimals := binary.BigEndian.Uint32(item[offset : offset+4]) + offset += 4 + + chainID := binary.BigEndian.Uint32(item[offset : offset+4]) + offset += 4 + + signature := item[offset:length] + + tokens = append(tokens, Token{ + Ticker: ticker, + Address: address, + Decimals: decimals, + ChainID: chainID, + Signature: signature, + Data: item, + }) + + i += length + } + + return &Tokens{ + tokens, + }, nil +} + +func (t *Tokens) ByContractAddressAndChainID(address common.Address, chainID *big.Int) (*Token, error) { + for _, token := range t.tokens { + if token.Address == address && uint64(token.ChainID) == chainID.Uint64() { + return &token, nil + } + } + + return nil, ErrCouldNotFindToken +} + +func IsERC20Transfer(data []byte) bool { + if len(data) < 4 { + return false + } + + // 0xa9059cbb is the ERC20 transfer function signature + if !bytes.Equal(data[:4], []byte{0xa9, 0x05, 0x9c, 0xbb}) { + return false + } + + return true +}

diff --git go-ethereum/accounts/abi/abi.go celo/accounts/abi/abi.go index efcaf3c30c5b445b6159a36213df44d937717dff..7f65daf1ffbb84cb8c73f82779ba9117b9189f16 100644 --- go-ethereum/accounts/abi/abi.go +++ celo/accounts/abi/abi.go @@ -42,6 +42,8 @@ Fallback Method // Note it's also used to represent legacy fallback before v0.6.0 Receive Method }   +var ErrEmptyArguments = errors.New("abi: attempting to unmarshall an empty string while arguments are expected") + // JSON returns a parsed ABI interface and error if it failed. func JSON(reader io.Reader) (ABI, error) { dec := json.NewDecoder(reader)

diff --git go-ethereum/accounts/abi/unpack.go celo/accounts/abi/unpack.go index 53609777d84987c48d71acd438ec1b8bbc5dbe74..86b6b10db30bd603edca1ec41c4b2ac8b0efe21d 100644 --- go-ethereum/accounts/abi/unpack.go +++ celo/accounts/abi/unpack.go @@ -188,6 +188,12 @@ } return retval.Interface(), nil }   +// ToGoType parses the output bytes and recursively assigns the value of these bytes +// into a go type with accordance with the ABI spec. +func ToGoType(index int, t Type, output []byte) (interface{}, error) { + return toGoType(index, t, output) +} + // toGoType parses the output bytes and recursively assigns the value of these bytes // into a go type with accordance with the ABI spec. func toGoType(index int, t Type, output []byte) (interface{}, error) {

diff --git go-ethereum/accounts/abi/argument.go celo/accounts/abi/argument.go index 1c1dd962eef3f4973d25a8a72368e45a188a8c2d..c3145b251a3f942d1bab9045b6fd953fe45505ac 100644 --- go-ethereum/accounts/abi/argument.go +++ celo/accounts/abi/argument.go @@ -79,7 +79,7 @@ // Unpack performs the operation hexdata -> Go format. func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) { if len(data) == 0 { if len(arguments) != 0 { - return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected") + return nil, ErrEmptyArguments } // Nothing to unmarshal, return default variables nonIndexedArgs := arguments.NonIndexed() @@ -100,7 +100,7 @@ return fmt.Errorf("abi: cannot unpack into a nil map") } if len(data) == 0 { if len(arguments) != 0 { - return fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected") + return ErrEmptyArguments } return nil // Nothing to unmarshal, return }

diff --git go-ethereum/accounts/abi/event_test.go celo/accounts/abi/event_test.go index ce9c4aeff983b9534059fe8ed9ae13591c10bd72..33419012195cbec89367bc4c104f82ee18b01db1 100644 --- go-ethereum/accounts/abi/event_test.go +++ celo/accounts/abi/event_test.go @@ -169,7 +169,7 @@ type EventTransferWithTag struct { // this is valid because `value` is not exportable, // so value is only unmarshalled into `Value1`. - value *big.Int //lint:ignore U1000 unused field is part of test + value *big.Int //nolint:unused // field is part of test Value1 *big.Int `abi:"value"` }

diff --git go-ethereum/accounts/abi/bind/base.go celo/accounts/abi/bind/base.go index d6fff9a695dfa54e3ac4d5331c8e88b1eaad7d7a..de7bc725231771855c6315dba25022796bc600ad 100644 --- go-ethereum/accounts/abi/bind/base.go +++ celo/accounts/abi/bind/base.go @@ -53,6 +53,9 @@ Signer SignerFn // Method to use for signing the transaction (mandatory)   Value *big.Int // Funds to transfer along the transaction (nil = 0 = no funds) GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) + FeeCurrency *common.Address // Fee currency to be used for transaction (nil = default currency = Celo Gold) + GatewayFeeRecipient *common.Address // Address to which gateway fees should be paid (nil = no gateway fees are paid) + GatewayFee *big.Int // Value of gateway fees to be paid (nil = no gateway fees are paid) GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) @@ -140,6 +143,11 @@ return common.Address{}, nil, nil, err } c.address = crypto.CreateAddress(opts.From, tx.Nonce()) return c.address, tx, c, nil +} + +// ABI returns the bound contract parsed ABI +func (c *BoundContract) ABI() abi.ABI { + return c.abi }   // Call invokes the (constant) contract method with params as input values and @@ -254,40 +262,55 @@ // Figure out reasonable gas price values if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) { return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") } - head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil) - if err != nil { - return nil, err + // head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil) + // if err != nil { + // return nil, err + // } + // TODO: Use GPM here + // if head.BaseFee != nil && opts.GasPrice == nil { + // if opts.GasTipCap == nil { + // tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context)) + // if err != nil { + // return nil, err + // } + // opts.GasTipCap = tip + // } + // if opts.GasFeeCap == nil { + // gasFeeCap := new(big.Int).Add( + // opts.GasTipCap, + // new(big.Int).Mul(head.BaseFee, big.NewInt(2)), + // ) + // opts.GasFeeCap = gasFeeCap + // } + // if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 { + // return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap) + // } + // } else { + if opts.GasFeeCap != nil || opts.GasTipCap != nil { + return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") } - if head.BaseFee != nil && opts.GasPrice == nil { - if opts.GasTipCap == nil { - tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context)) - if err != nil { - return nil, err - } - opts.GasTipCap = tip - } - if opts.GasFeeCap == nil { - gasFeeCap := new(big.Int).Add( - opts.GasTipCap, - new(big.Int).Mul(head.BaseFee, big.NewInt(2)), - ) - opts.GasFeeCap = gasFeeCap - } - if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 { - return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap) - } - } else { - if opts.GasFeeCap != nil || opts.GasTipCap != nil { - return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") + if opts.GasPrice == nil { + price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context)) + if err != nil { + return nil, err } - if opts.GasPrice == nil { - price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context)) - if err != nil { - return nil, err - } - opts.GasPrice = price - } + opts.GasPrice = price } + // } + + feeCurrency := opts.FeeCurrency + // TODO(nategraf): Add SuggestFeeCurrency to Transactor to get fee currency + // Otherwise, the user might not be able to pay in non-native currency for contract + // deployment. Paying for Contract deployment in non-native currency might not work right now. + // Only paying for token transfer in non-native currency is supported. + //if feeCurrency == 0 { + // feeCurrency = c.transactor.SuggestFeeCurrency(opts.Context) + //} + + gatewayFeeRecipient := opts.GatewayFeeRecipient + gatewayFee := opts.GatewayFee + // TODO(nategraf): Add SuggestGatewayFee to Transactor. + gasLimit := opts.GasLimit if gasLimit == 0 { // Gas estimation cannot succeed without code for method invocations @@ -299,7 +322,18 @@ return nil, ErrNoCode } } // If the contract surely has code (or code is not needed), estimate the transaction - msg := ethereum.CallMsg{From: opts.From, To: contract, GasPrice: opts.GasPrice, GasTipCap: opts.GasTipCap, GasFeeCap: opts.GasFeeCap, Value: value, Data: input} + msg := ethereum.CallMsg{ + From: opts.From, + To: contract, + GasPrice: opts.GasPrice, + GasTipCap: opts.GasTipCap, + GasFeeCap: opts.GasFeeCap, + Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, + Data: input, + } gasLimit, err = c.transactor.EstimateGas(ensureContext(opts.Context), msg) if err != nil { return nil, fmt.Errorf("failed to estimate gas needed: %v", err) @@ -313,6 +347,9 @@ Nonce: nonce, GasPrice: opts.GasPrice, Gas: gasLimit, Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, Data: input, } if contract != nil { @@ -347,6 +384,19 @@ if err := c.transactor.SendTransaction(ensureContext(opts.Context), signedTx); err != nil { return nil, err } return signedTx, nil +} + +// LogEventName will verify the log belongs to the contract and return the eventName for it +func (c *BoundContract) LogEventName(log types.Log) (eventName string, ok bool, err error) { + if log.Address != c.address || len(log.Topics) < 1 { + return "", false, err + } + + event, err := c.abi.EventByID(log.Topics[0]) + if err != nil { + return "", false, err + } + return event.Name, true, nil }   // FilterLogs filters contract logs for past blocks, returning the necessary

diff --git go-ethereum/accounts/abi/bind/util_test.go celo/accounts/abi/bind/util_test.go index e97ad65a10642d8a02afa09cf86f23970ebc81e3..cd9edf19ca6dabab52a03846c56f59e7b477f66d 100644 --- go-ethereum/accounts/abi/bind/util_test.go +++ celo/accounts/abi/bind/util_test.go @@ -33,6 +33,8 @@ )   var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")   +var genericBaseFee = big.NewInt(2) // set a constant gas price to be above the GPM. + var waitDeployedTests = map[string]struct { code string gas uint64 @@ -55,18 +57,14 @@ func TestWaitDeployed(t *testing.T) { for name, test := range waitDeployedTests { backend := backends.NewSimulatedBackend( - core.GenesisAlloc{ - crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}, - }, - 10000000, - ) + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) defer backend.Close()   // Create the transaction - head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code)) + tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, nil, nil, nil, common.FromHex(test.code)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)   // Wait for it to get mined in the background. @@ -101,19 +99,16 @@ }   func TestWaitDeployedCornerCases(t *testing.T) { backend := backends.NewSimulatedBackend( - core.GenesisAlloc{ - crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}, - }, - 10000000, - ) + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) defer backend.Close()   - head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   // Create a transaction to an account. code := "6060604052600a8060106000396000f360606040526008565b00" - tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code)) + tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, + gasPrice, nil, nil, nil, common.FromHex(code)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -125,7 +120,7 @@ t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err) }   // Create a transaction that is not mined. - tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code)) + tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, nil, nil, nil, common.FromHex(code)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)   go func() {

diff --git go-ethereum/accounts/abi/bind/template.go celo/accounts/abi/bind/template.go index 165c3b2d0e2479758b9dcee28619b5f471aab629..e14b27690f25f713e92869a246062208a757072e 100644 --- go-ethereum/accounts/abi/bind/template.go +++ celo/accounts/abi/bind/template.go @@ -275,6 +275,15 @@ } return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil }   + // Parse{{.Type}}ABI parses the ABI + func Parse{{.Type}}ABI() (*abi.ABI, error) { + parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) + if err != nil { + return nil, err + } + return &parsed, nil + } + // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named @@ -378,7 +387,25 @@ return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}}) } {{end}}   - {{if .Fallback}} + // TryParseLog attempts to parse a log. Returns the parsed log, evenName and whether it was succesfull + func (_{{$contract.Type}} *{{$contract.Type}}Filterer) TryParseLog(log types.Log) (eventName string, event interface{}, ok bool, err error) { + eventName, ok, err = _{{$contract.Type}}.contract.LogEventName(log) + if err != nil || !ok { + return "", nil, false, err + } + + switch eventName { {{range .Events}} + case "{{.Normalized.Name}}": + event, err = _{{$contract.Type}}.Parse{{.Normalized.Name}}(log){{end}} + } + if err != nil { + return "", nil, false, err + } + + return eventName, event, ok, nil + } + + {{if .Fallback}} // Fallback is a paid mutator transaction binding the contract fallback function. // // Solidity: {{.Fallback.Original.String}} @@ -392,7 +419,7 @@ // Solidity: {{.Fallback.Original.String}} func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) { return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata) } - + // Fallback is a paid mutator transaction binding the contract fallback function. // // Solidity: {{.Fallback.Original.String}} @@ -401,7 +428,7 @@ return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata) } {{end}}   - {{if .Receive}} + {{if .Receive}} // Receive is a paid mutator transaction binding the contract receive function. // // Solidity: {{.Receive.Original.String}} @@ -415,7 +442,7 @@ // Solidity: {{.Receive.Original.String}} func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) { return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts) } - + // Receive is a paid mutator transaction binding the contract receive function. // // Solidity: {{.Receive.Original.String}}

diff --git go-ethereum/accounts/abi/bind/bind_test.go celo/accounts/abi/bind/bind_test.go index c3343531e3ffa8dde035134f615501acfca56339..03e4c0760e417b76e6e04ae9401527c3a1cf0b1d 100644 --- go-ethereum/accounts/abi/bind/bind_test.go +++ celo/accounts/abi/bind/bind_test.go @@ -298,7 +298,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy an interaction tester contract and call a transaction on it @@ -353,7 +353,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a tuple tester contract and execute a structured call on it @@ -399,7 +399,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a tuple tester contract and execute a structured call on it @@ -457,7 +457,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a slice tester contract and execute a n array call on it @@ -505,7 +505,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a default method invoker contract and execute its default method @@ -571,7 +571,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a structs method invoker contract and execute its default method @@ -614,7 +614,7 @@ `, ` // Create a simulator and wrap a non-deployed contract   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000)) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close()   nonexistent, err := NewNonExistent(common.Address{}, sim) @@ -653,7 +653,7 @@ `, ` // Create a simulator and wrap a non-deployed contract   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000)) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{},) defer sim.Close()   nonexistent, err := NewNonExistentStruct(common.Address{}, sim) @@ -703,7 +703,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a funky gas pattern contract @@ -753,7 +753,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a sender tester contract and execute a structured call on it @@ -828,7 +828,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a underscorer tester contract and execute a structured call on it @@ -922,7 +922,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy an eventer contract @@ -1112,7 +1112,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   //deploy the test contract @@ -1247,7 +1247,7 @@ ` key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   _, _, contract, err := DeployTuple(auth, sim) @@ -1389,7 +1389,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   //deploy the test contract @@ -1454,7 +1454,7 @@ ` // Initialize test accounts key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // deploy the test contract @@ -1544,7 +1544,7 @@ key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey)   // Deploy registrar contract - sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) @@ -1606,7 +1606,7 @@ key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey)   // Deploy registrar contract - sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) @@ -1668,7 +1668,7 @@ // Generate a new random account and a funded simulator key, _ := crypto.GenerateKey() auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   // Deploy a tester contract and execute a structured call on it @@ -1728,7 +1728,7 @@ ` key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey)   - sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 1000000) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}) defer sim.Close()   opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) @@ -1811,13 +1811,12 @@ "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/eth/ethconfig" `, ` var ( key, _ = crypto.GenerateKey() user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) - sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil) + sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}) ) defer sim.Close()   @@ -1917,7 +1916,7 @@ if out, err := moder.CombinedOutput(); err != nil { t.Fatalf("failed to convert binding test to modules: %v\n%s", err, out) } pwd, _ := os.Getwd() - replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/ethereum/go-ethereum="+filepath.Join(pwd, "..", "..", "..")) // Repo root + replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/celo-org/celo-blockchain="+filepath.Join(pwd, "..", "..", "..")) // Repo root replacer.Dir = pkg if out, err := replacer.CombinedOutput(); err != nil { t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)

diff --git go-ethereum/accounts/abi/bind/backends/simulated_test.go celo/accounts/abi/bind/backends/simulated_test.go index 1d17c1254db0e2698961174601813a03d98c6a72..6b84336a2edf90b894d48d489b82f4c457bbf9c1 100644 --- go-ethereum/accounts/abi/bind/backends/simulated_test.go +++ celo/accounts/abi/bind/backends/simulated_test.go @@ -37,14 +37,15 @@ "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/params" )   +var genericBaseFee = big.NewInt(2) // set a constant gas price to be above the GPM. + func TestSimulatedBackend(t *testing.T) { - var gasLimit uint64 = 8000029 key, _ := crypto.GenerateKey() // nolint: gosec auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337)) genAlloc := make(core.GenesisAlloc) genAlloc[auth.From] = core.GenesisAccount{Balance: big.NewInt(9223372036854775807)}   - sim := NewSimulatedBackend(genAlloc, gasLimit) + sim := NewSimulatedBackend(genAlloc) defer sim.Close()   // should return an error if the tx is not found @@ -59,12 +60,11 @@ t.Fatalf("err should be `ethereum.NotFound` but received %v", err) }   // generate a transaction and confirm you can retrieve it - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   code := `6060604052600a8060106000396000f360606040526008565b00` var gas uint64 = 3000000 - tx := types.NewContractCreation(0, big.NewInt(0), gas, gasPrice, common.FromHex(code)) + tx := types.NewContractCreation(0, big.NewInt(0), gas, gasPrice, nil, nil, nil, common.FromHex(code)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, key)   err = sim.SendTransaction(context.Background(), tx) @@ -115,7 +115,7 @@ func simTestBackend(testAddr common.Address) *SimulatedBackend { return NewSimulatedBackend( core.GenesisAlloc{ testAddr: {Balance: big.NewInt(10000000000000000)}, - }, 10000000, + }, ) }   @@ -125,12 +125,12 @@ expectedBal := big.NewInt(10000000000000000) sim := simTestBackend(testAddr) defer sim.Close()   - if sim.config != params.AllEthashProtocolChanges { - t.Errorf("expected sim config to equal params.AllEthashProtocolChanges, got %v", sim.config) + if sim.config != params.IstanbulTestChainConfig { + t.Errorf("expected sim config to equal params.IstanbulTestChainConfig, got %v", sim.config) }   - if sim.blockchain.Config() != params.AllEthashProtocolChanges { - t.Errorf("expected sim blockchain config to equal params.AllEthashProtocolChanges, got %v", sim.config) + if sim.blockchain.Config() != params.IstanbulTestChainConfig { + t.Errorf("expected sim blockchain config to equal params.IstanbulTestChainConfig, got %v", sim.config) }   stateDB, _ := sim.blockchain.State() @@ -141,9 +141,7 @@ } }   func TestAdjustTime(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close()   prevTime := sim.pendingBlock.Time() @@ -162,10 +160,9 @@ testAddr := crypto.PubkeyToAddress(testKey.PublicKey) sim := simTestBackend(testAddr)   // Create tx and send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -186,7 +183,7 @@ if newTime-prevTime != uint64(time.Minute.Seconds()) { t.Errorf("adjusted time not equal to a minute. prev: %v, new: %v", prevTime, newTime) } // Put a transaction after adjusting time - tx2 := types.NewTransaction(1, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx2 := types.NewTransaction(1, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx2, err := types.SignTx(tx2, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -217,9 +214,7 @@ } }   func TestBlockByHash(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close() bgCtx := context.Background()   @@ -238,9 +233,7 @@ } }   func TestBlockByNumber(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close() bgCtx := context.Background()   @@ -289,10 +282,10 @@ t.Errorf("received incorrect nonce. expected 0, got %v", nonce) }   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(nonce, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(nonce, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -333,10 +326,10 @@ defer sim.Close() bgCtx := context.Background()   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -365,16 +358,16 @@ sim := NewSimulatedBackend( core.GenesisAlloc{ testAddr: {Balance: big.NewInt(10000000000000000)}, - }, 10000000, + }, ) defer sim.Close() bgCtx := context.Background()   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -430,7 +423,7 @@ key, _ := crypto.GenerateKey() addr := crypto.PubkeyToAddress(key.PublicKey) opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))   - sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether)}}, 10000000) + sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether)}}) defer sim.Close()   parsed, _ := abi.JSON(strings.NewReader(contractAbi)) @@ -531,96 +524,6 @@ } } }   -func TestEstimateGasWithPrice(t *testing.T) { - key, _ := crypto.GenerateKey() - addr := crypto.PubkeyToAddress(key.PublicKey) - - sim := NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(params.Ether*2 + 2e17)}}, 10000000) - defer sim.Close() - - recipient := common.HexToAddress("deadbeef") - var cases = []struct { - name string - message ethereum.CallMsg - expect uint64 - expectError error - }{ - {"EstimateWithoutPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(0), - Value: big.NewInt(100000000000), - Data: nil, - }, 21000, nil}, - - {"EstimateWithPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(100000000000), - Value: big.NewInt(100000000000), - Data: nil, - }, 21000, nil}, - - {"EstimateWithVeryHighPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(1e14), // gascost = 2.1ether - Value: big.NewInt(1e17), // the remaining balance for fee is 2.1ether - Data: nil, - }, 21000, nil}, - - {"EstimateWithSuperhighPrice", ethereum.CallMsg{ - From: addr, - To: &recipient, - Gas: 0, - GasPrice: big.NewInt(2e14), // gascost = 4.2ether - Value: big.NewInt(100000000000), - Data: nil, - }, 21000, errors.New("gas required exceeds allowance (10999)")}, // 10999=(2.2ether-1000wei)/(2e14) - - {"EstimateEIP1559WithHighFees", ethereum.CallMsg{ - From: addr, - To: &addr, - Gas: 0, - GasFeeCap: big.NewInt(1e14), // maxgascost = 2.1ether - GasTipCap: big.NewInt(1), - Value: big.NewInt(1e17), // the remaining balance for fee is 2.1ether - Data: nil, - }, params.TxGas, nil}, - - {"EstimateEIP1559WithSuperHighFees", ethereum.CallMsg{ - From: addr, - To: &addr, - Gas: 0, - GasFeeCap: big.NewInt(1e14), // maxgascost = 2.1ether - GasTipCap: big.NewInt(1), - Value: big.NewInt(1e17 + 1), // the remaining balance for fee is 2.1ether - Data: nil, - }, params.TxGas, errors.New("gas required exceeds allowance (20999)")}, // 20999=(2.2ether-0.1ether-1wei)/(1e14) - } - for i, c := range cases { - got, err := sim.EstimateGas(context.Background(), c.message) - if c.expectError != nil { - if err == nil { - t.Fatalf("test %d: expect error, got nil", i) - } - if c.expectError.Error() != err.Error() { - t.Fatalf("test %d: expect error, want %v, got %v", i, c.expectError, err) - } - continue - } - if c.expectError == nil && err != nil { - t.Fatalf("test %d: didn't expect error, got %v", i, err) - } - if got != c.expect { - t.Fatalf("test %d: gas estimation mismatch, want %d, got %d", i, c.expect, got) - } - } -} - func TestHeaderByHash(t *testing.T) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey)   @@ -709,10 +612,10 @@ if count != 0 { t.Errorf("expected transaction count of %v does not match actual count of %v", 0, count) } // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -766,10 +669,10 @@ if pendingNonce != uint64(0) { t.Errorf("expected pending nonce of 0 got %v", pendingNonce) } // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -824,10 +727,10 @@ t.Errorf("expected pending nonce of 0 got %v", pendingNonce) }   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -850,7 +753,7 @@ t.Errorf("expected pending nonce of 1 got %v", pendingNonce) }   // make a new transaction with a nonce of 1 - tx = types.NewTransaction(uint64(1), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx = types.NewTransaction(uint64(1), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err = types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -879,10 +782,10 @@ defer sim.Close() bgCtx := context.Background()   // create a signed transaction to send - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + //// head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + tx := types.NewTransaction(uint64(0), testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, testKey) if err != nil { t.Errorf("could not sign tx: %v", err) @@ -906,10 +809,7 @@ } }   func TestSuggestGasPrice(t *testing.T) { - sim := NewSimulatedBackend( - core.GenesisAlloc{}, - 10000000, - ) + sim := NewSimulatedBackend(core.GenesisAlloc{}) defer sim.Close() bgCtx := context.Background() gasPrice, err := sim.SuggestGasPrice(bgCtx) @@ -1308,10 +1208,10 @@ defer sim.Close() // 1. parent := sim.blockchain.CurrentBlock() // 2. - head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough - gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) + // head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1))   - _tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil) + _tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil, nil, nil, nil) tx, _ := types.SignTx(_tx, types.HomesteadSigner{}, testKey) sim.SendTransaction(context.Background(), tx) sim.Commit()

diff --git go-ethereum/accounts/abi/bind/backends/simulated.go celo/accounts/abi/bind/backends/simulated.go index 9af21b95741bb0d67e7576b541d6ee5b17bbfbe0..c717f8fcdbfa214eae7aa5be2651ea25a8247e4c 100644 --- go-ethereum/accounts/abi/bind/backends/simulated.go +++ celo/accounts/abi/bind/backends/simulated.go @@ -30,7 +30,8 @@ "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/math" - "github.com/ethereum/go-ethereum/consensus/ethash" + mockEngine "github.com/ethereum/go-ethereum/consensus/consensustest" + "github.com/ethereum/go-ethereum/contracts/blockchain_parameters" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/bloombits" "github.com/ethereum/go-ethereum/core/rawdb" @@ -40,7 +41,6 @@ "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/filters" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rpc" ) @@ -75,10 +75,10 @@ // NewSimulatedBackendWithDatabase creates a new binding backend based on the given database // and uses a simulated blockchain for testing purposes. // A simulated backend always uses chainID 1337. -func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend { - genesis := core.Genesis{Config: params.AllEthashProtocolChanges, GasLimit: gasLimit, Alloc: alloc} +func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc) *SimulatedBackend { + genesis := core.Genesis{Config: params.IstanbulTestChainConfig, Alloc: alloc} genesis.MustCommit(database) - blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}, nil, nil) + blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, mockEngine.NewFaker(), vm.Config{}, nil, nil)   backend := &SimulatedBackend{ database: database, @@ -93,8 +93,8 @@ // NewSimulatedBackend creates a new binding backend using a simulated blockchain // for testing purposes. // A simulated backend always uses chainID 1337. -func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend { - return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc, gasLimit) +func NewSimulatedBackend(alloc core.GenesisAlloc) *SimulatedBackend { + return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc) }   // Close terminates the underlying blockchain's update loop. @@ -126,7 +126,7 @@ b.rollback(b.blockchain.CurrentBlock()) }   func (b *SimulatedBackend) rollback(parent *types.Block) { - blocks, _ := core.GenerateChain(b.config, parent, ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {}) + blocks, _ := core.GenerateChain(b.config, parent, mockEngine.NewFaker(), b.database, 1, func(int, *core.BlockGen) {})   b.pendingBlock = blocks[0] b.pendingState, _ = state.New(b.pendingBlock.Root(), b.blockchain.StateCache(), nil) @@ -471,6 +471,18 @@ func (b *SimulatedBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) { return big.NewInt(1), nil }   +// CurrentGasPriceMinimum implements ContractTransactor.CurrentGasPriceMinimum. Since the simulated +// chain doesn't have miners, we just return a gas tip of 1 for any call. +func (b *SimulatedBackend) CurrentGasPriceMinimum(ctx context.Context, currencyAddress *common.Address) (*big.Int, error) { + return big.NewInt(1), nil +} + +// GasPriceMinimumForHeader implements ContractTransactor.GasPriceMinimumForHeader. Since the simulated +// chain doesn't have miners, we just return a gas tip of 1 for any call. +func (b *SimulatedBackend) GasPriceMinimumForHeader(ctx context.Context, currencyAddress *common.Address, header *types.Header) (*big.Int, error) { + return big.NewInt(1), nil +} + // EstimateGas executes the requested code against the currently pending block/state and // returns the used amount of gas. func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) { @@ -486,39 +498,8 @@ ) if call.Gas >= params.TxGas { hi = call.Gas } else { - hi = b.pendingBlock.GasLimit() - } - // Normalize the max fee per gas the call is willing to spend. - var feeCap *big.Int - if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) { - return 0, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") - } else if call.GasPrice != nil { - feeCap = call.GasPrice - } else if call.GasFeeCap != nil { - feeCap = call.GasFeeCap - } else { - feeCap = common.Big0 - } - // Recap the highest gas allowance with account's balance. - if feeCap.BitLen() != 0 { - balance := b.pendingState.GetBalance(call.From) // from can't be nil - available := new(big.Int).Set(balance) - if call.Value != nil { - if call.Value.Cmp(available) >= 0 { - return 0, errors.New("insufficient funds for transfer") - } - available.Sub(available, call.Value) - } - allowance := new(big.Int).Div(available, feeCap) - if allowance.IsUint64() && hi > allowance.Uint64() { - transfer := call.Value - if transfer == nil { - transfer = new(big.Int) - } - log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance, - "sent", transfer, "feecap", feeCap, "fundable", allowance) - hi = allowance.Uint64() - } + vmRunner := b.blockchain.NewEVMRunner(b.pendingBlock.Header(), b.pendingState) + hi = blockchain_parameters.GetBlockGasLimitOrDefault(vmRunner) } cap = hi   @@ -583,7 +564,7 @@ if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) { return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") } head := b.blockchain.CurrentHeader() - if !b.blockchain.Config().IsLondon(head.Number) { + if !b.blockchain.Config().IsEspresso(head.Number) { // If there's no basefee, then it must be a non-1559 execution if call.GasPrice == nil { call.GasPrice = new(big.Int) @@ -605,7 +586,11 @@ } // Backfill the legacy gasPrice for EVM execution, unless we're all zeroes call.GasPrice = new(big.Int) if call.GasFeeCap.BitLen() > 0 || call.GasTipCap.BitLen() > 0 { - call.GasPrice = math.BigMin(new(big.Int).Add(call.GasTipCap, head.BaseFee), call.GasFeeCap) + gasPriceMinimum, err := b.CurrentGasPriceMinimum(ctx, call.FeeCurrency) + if err != nil { + return nil, err + } + call.GasPrice = math.BigMin(new(big.Int).Add(call.GasTipCap, gasPriceMinimum), call.GasFeeCap) } } } @@ -622,14 +607,23 @@ from.SetBalance(math.MaxBig256) // Execute the call. msg := callMsg{call}   - txContext := core.NewEVMTxContext(msg) - evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil) // Create a new environment which holds all relevant information // about the transaction and calling mechanisms. + txContext := core.NewEVMTxContext(msg) + evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil) vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true}) gasPool := new(core.GasPool).AddGas(math.MaxUint64) - - return core.NewStateTransition(vmEnv, msg, gasPool).TransitionDb() + vmRunner := b.blockchain.NewEVMRunner(block.Header(), stateDB) + var sysCtx *core.SysContractCallCtx + if b.config.IsEspresso(block.Number()) { + parent := b.blockchain.GetBlockByNumber(block.NumberU64() - 1) + sysStateDB, err := b.blockchain.StateAt(parent.Root()) + if err != nil { + return nil, err + } + sysCtx = core.NewSysContractCallCtx(block.Header(), sysStateDB, b.blockchain) + } + return core.NewStateTransition(vmEnv, msg, gasPool, vmRunner, sysCtx).TransitionDb() }   // SendTransaction updates the pending block to include the given transaction. @@ -654,7 +648,7 @@ if tx.Nonce() != nonce { panic(fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)) } // Include tx in chain - blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, block, mockEngine.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { for _, tx := range b.pendingBlock.Transactions() { block.AddTxWithChain(b.blockchain, tx) } @@ -769,10 +763,10 @@ b.mu.Lock() defer b.mu.Unlock()   if len(b.pendingBlock.Transactions()) != 0 { - return errors.New("Could not adjust time on non-empty block") + return errors.New("could not adjust time on non-empty block") }   - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), mockEngine.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { block.OffsetTime(int64(adjustment.Seconds())) }) stateDB, _ := b.blockchain.State() @@ -800,9 +794,13 @@ func (m callMsg) To() *common.Address { return m.CallMsg.To } func (m callMsg) GasPrice() *big.Int { return m.CallMsg.GasPrice } func (m callMsg) GasFeeCap() *big.Int { return m.CallMsg.GasFeeCap } func (m callMsg) GasTipCap() *big.Int { return m.CallMsg.GasTipCap } +func (m callMsg) FeeCurrency() *common.Address { return m.CallMsg.FeeCurrency } +func (m callMsg) GatewayFeeRecipient() *common.Address { return m.CallMsg.GatewayFeeRecipient } +func (m callMsg) GatewayFee() *big.Int { return m.CallMsg.GatewayFee } func (m callMsg) Gas() uint64 { return m.CallMsg.Gas } func (m callMsg) Value() *big.Int { return m.CallMsg.Value } func (m callMsg) Data() []byte { return m.CallMsg.Data } +func (m callMsg) EthCompatible() bool { return m.CallMsg.EthCompatible } func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }   // filterBackend implements filters.Backend to support filtering for logs without @@ -874,6 +872,10 @@ func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }   func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) { panic("not supported") +} + +func (fb *filterBackend) RealGasPriceMinimumForHeader(ctx context.Context, currencyAddress *common.Address, header *types.Header) (*big.Int, error) { + return nil, fmt.Errorf("filterBackend does not implement RealGasPriceMinimumForHeader") }   func nullSubscription() event.Subscription {

diff --git go-ethereum/accounts/abi/bind_v2/base_test.go celo/accounts/abi/bind_v2/base_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5960c702a07e7b00b3890be12530a0484e5e0d88 --- /dev/null +++ celo/accounts/abi/bind_v2/base_test.go @@ -0,0 +1,258 @@ +// Copyright 2019 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "math/big" + "reflect" + "strings" + "testing" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rlp" +) + +type mockCaller struct { + codeAtBlockNumber *big.Int + callContractBlockNumber *big.Int + pendingCodeAtCalled bool + pendingCallContractCalled bool +} + +func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) { + mc.codeAtBlockNumber = blockNumber + return []byte{1, 2, 3}, nil +} + +func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) { + mc.callContractBlockNumber = blockNumber + return nil, nil +} + +func (mc *mockCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) { + mc.pendingCodeAtCalled = true + return nil, nil +} + +func (mc *mockCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) { + mc.pendingCallContractCalled = true + return nil, nil +} +func TestPassingBlockNumber(t *testing.T) { + + mc := &mockCaller{} + + bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{ + Methods: map[string]abi.Method{ + "something": { + Name: "something", + Outputs: abi.Arguments{}, + }, + }, + }, mc, nil, nil) + var ret []interface{} + + blockNumber := big.NewInt(42) + + bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, &ret, "something") + + if mc.callContractBlockNumber != blockNumber { + t.Fatalf("CallContract() was not passed the block number") + } + + if mc.codeAtBlockNumber != blockNumber { + t.Fatalf("CodeAt() was not passed the block number") + } + + bc.Call(&bind.CallOpts{}, &ret, "something") + + if mc.callContractBlockNumber != nil { + t.Fatalf("CallContract() was passed a block number when it should not have been") + } + + if mc.codeAtBlockNumber != nil { + t.Fatalf("CodeAt() was passed a block number when it should not have been") + } + + bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, &ret, "something") + + if !mc.pendingCallContractCalled { + t.Fatalf("CallContract() was not passed the block number") + } + + if !mc.pendingCodeAtCalled { + t.Fatalf("CodeAt() was not passed the block number") + } +} + +const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158" + +func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) { + hash := crypto.Keccak256Hash([]byte("testName")) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(string,address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x0")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"name","type":"string"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "name": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) { + sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"}) + if err != nil { + t.Fatal(err) + } + hash := crypto.Keccak256Hash(sliceBytes) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(string[],address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x0")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"names","type":"string[]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "names": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) { + arrBytes, err := rlp.EncodeToBytes([2]common.Address{common.HexToAddress("0x0"), common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")}) + if err != nil { + t.Fatal(err) + } + hash := crypto.Keccak256Hash(arrBytes) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(address[2],address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x0")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"addresses","type":"address[2]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "addresses": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) { + mockAddress := common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2") + addrBytes := mockAddress.Bytes() + hash := crypto.Keccak256Hash([]byte("mockFunction(address,uint)")) + functionSelector := hash[:4] + functionTyBytes := append(addrBytes, functionSelector...) + var functionTy [24]byte + copy(functionTy[:], functionTyBytes[0:24]) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(function,address,uint256,bytes)")), + common.BytesToHash(functionTyBytes), + } + mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42")) + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"function","type":"function"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "function": functionTy, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) { + bytes := []byte{1, 2, 3, 4, 5} + hash := crypto.Keccak256Hash(bytes) + topics := []common.Hash{ + crypto.Keccak256Hash([]byte("received(bytes,address,uint256,bytes)")), + hash, + } + mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42")) + + abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"content","type":"bytes"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + parsedAbi, _ := abi.JSON(strings.NewReader(abiString)) + bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil) + + expectedReceivedMap := map[string]interface{}{ + "content": hash, + "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"), + "amount": big.NewInt(1), + "memo": []byte{88}, + } + unpackAndCheck(t, bc, expectedReceivedMap, mockLog) +} + +func unpackAndCheck(t *testing.T, bc *bind.BoundContract, expected map[string]interface{}, mockLog types.Log) { + received := make(map[string]interface{}) + if err := bc.UnpackLogIntoMap(received, "received", mockLog); err != nil { + t.Error(err) + } + + if len(received) != len(expected) { + t.Fatalf("unpacked map length %v not equal expected length of %v", len(received), len(expected)) + } + for name, elem := range expected { + if !reflect.DeepEqual(elem, received[name]) { + t.Errorf("field %v does not match expected, want %v, got %v", name, elem, received[name]) + } + } +} + +func newMockLog(topics []common.Hash, txHash common.Hash) types.Log { + return types.Log{ + Address: common.HexToAddress("0x0"), + Topics: topics, + Data: hexutil.MustDecode(hexData), + BlockNumber: uint64(26), + TxHash: txHash, + TxIndex: 111, + BlockHash: common.BytesToHash([]byte{1, 2, 3, 4, 5}), + Index: 7, + Removed: false, + } +}

diff --git go-ethereum/accounts/abi/bind_v2/bind.go celo/accounts/abi/bind_v2/bind.go new file mode 100644 index 0000000000000000000000000000000000000000..40ebb0bf4f6e7c0f9c143d38541e1b997209d0aa --- /dev/null +++ celo/accounts/abi/bind_v2/bind.go @@ -0,0 +1,492 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +// Package bind generates Ethereum contract Go bindings. +// +// Detailed usage document and tutorial available on the go-ethereum Wiki page: +// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts +package bind_v2 + +import ( + "bytes" + "fmt" + "go/format" + "regexp" + "strings" + "text/template" + "unicode" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/log" +) + +// Lang is a target programming language selector to generate bindings for. +type Lang int + +const ( + LangGo Lang = iota +) + +// Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant +// to be used as is in client code, but rather as an intermediate struct which +// enforces compile time type safety and naming convention opposed to having to +// manually maintain hard coded strings that break on runtime. +func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) { + var ( + // contracts is the map of each individual contract requested binding + contracts = make(map[string]*tmplContract) + + // structs is the map of all reclared structs shared by passed contracts. + structs = make(map[string]*tmplStruct) + + // isLib is the map used to flag each encountered library as such + isLib = make(map[string]struct{}) + ) + for i := 0; i < len(types); i++ { + // Parse the actual ABI to generate the binding for + evmABI, err := abi.JSON(strings.NewReader(abis[i])) + if err != nil { + return "", err + } + // Strip any whitespace from the JSON ABI + strippedABI := strings.Map(func(r rune) rune { + if unicode.IsSpace(r) { + return -1 + } + return r + }, abis[i]) + + // Extract the call and transact methods; events, struct definitions; and sort them alphabetically + var ( + calls = make(map[string]*tmplMethod) + transacts = make(map[string]*tmplMethod) + events = make(map[string]*tmplEvent) + fallback *tmplMethod + receive *tmplMethod + + // identifiers are used to detect duplicated identifier of function + // and event. For all calls, transacts and events, abigen will generate + // corresponding bindings. However we have to ensure there is no + // identifier coliision in the bindings of these categories. + callIdentifiers = make(map[string]bool) + transactIdentifiers = make(map[string]bool) + eventIdentifiers = make(map[string]bool) + ) + for _, original := range evmABI.Methods { + // Normalize the method for capital cases and non-anonymous inputs/outputs + normalized := original + normalizedName := methodNormalizer[lang](alias(aliases, original.Name)) + // Ensure there is no duplicated identifier + var identifiers = callIdentifiers + if !original.IsConstant() { + identifiers = transactIdentifiers + } + if identifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + identifiers[normalizedName] = true + normalized.Name = normalizedName + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + bindStructType[lang](input.Type, structs) + } + } + normalized.Outputs = make([]abi.Argument, len(original.Outputs)) + copy(normalized.Outputs, original.Outputs) + for j, output := range normalized.Outputs { + if output.Name != "" { + normalized.Outputs[j].Name = capitalise(output.Name) + } + if hasStruct(output.Type) { + bindStructType[lang](output.Type, structs) + } + } + // Append the methods to the call or transact lists + if original.IsConstant() { + calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + } else { + transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + } + } + for _, original := range evmABI.Events { + // Skip anonymous events as they don't support explicit filtering + if original.Anonymous { + continue + } + // Normalize the event for capital cases and non-anonymous outputs + normalized := original + + // Ensure there is no duplicated identifier + normalizedName := methodNormalizer[lang](alias(aliases, original.Name)) + if eventIdentifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + eventIdentifiers[normalizedName] = true + normalized.Name = normalizedName + + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + bindStructType[lang](input.Type, structs) + } + } + // Append the event to the accumulator list + events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} + } + // Add two special fallback functions if they exist + if evmABI.HasFallback() { + fallback = &tmplMethod{Original: evmABI.Fallback} + } + if evmABI.HasReceive() { + receive = &tmplMethod{Original: evmABI.Receive} + } + + contracts[types[i]] = &tmplContract{ + Type: capitalise(types[i]), + InputABI: strings.Replace(strippedABI, "\"", "\\\"", -1), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: calls, + Transacts: transacts, + Fallback: fallback, + Receive: receive, + Events: events, + Libraries: make(map[string]string), + } + // Function 4-byte signatures are stored in the same sequence + // as types, if available. + if len(fsigs) > i { + contracts[types[i]].FuncSigs = fsigs[i] + } + // Parse library references. + for pattern, name := range libs { + matched, err := regexp.Match("__\\$"+pattern+"\\$__", []byte(contracts[types[i]].InputBin)) + if err != nil { + log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err) + } + if matched { + contracts[types[i]].Libraries[pattern] = name + // keep track that this type is a library + if _, ok := isLib[name]; !ok { + isLib[name] = struct{}{} + } + } + } + } + // Check if that type has already been identified as a library + for i := 0; i < len(types); i++ { + _, ok := isLib[types[i]] + contracts[types[i]].Library = ok + } + // Generate the contract template data content and render it + data := &tmplData{ + Package: pkg, + Contracts: contracts, + Libraries: libs, + Structs: structs, + } + buffer := new(bytes.Buffer) + + funcs := map[string]interface{}{ + "bindtype": bindType[lang], + "bindtopictype": bindTopicType[lang], + "namedtype": namedType[lang], + "formatmethod": formatMethod, + "formatevent": formatEvent, + "capitalise": capitalise, + "decapitalise": decapitalise, + } + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) + if err := tmpl.Execute(buffer, data); err != nil { + return "", err + } + // For Go bindings pass the code through gofmt to clean it up + if lang == LangGo { + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) + } + return string(code), nil + } + // For all others just return as is for now + return buffer.String(), nil +} + +// bindType is a set of type binders that convert Solidity types to some supported +// programming language types. +var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ + LangGo: bindTypeGo, +} + +// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go one. +func bindBasicTypeGo(kind abi.Type) string { + switch kind.T { + case abi.AddressTy: + return "common.Address" + case abi.IntTy, abi.UintTy: + parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String()) + switch parts[2] { + case "8", "16", "32", "64": + return fmt.Sprintf("%sint%s", parts[1], parts[2]) + } + return "*big.Int" + case abi.FixedBytesTy: + return fmt.Sprintf("[%d]byte", kind.Size) + case abi.BytesTy: + return "[]byte" + case abi.FunctionTy: + return "[24]byte" + default: + // string, bool types + return kind.String() + } +} + +// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping +// from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly +// mapped will use an upscaled type (e.g. BigDecimal). +func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { + switch kind.T { + case abi.TupleTy: + return structs[kind.TupleRawName+kind.String()].Name + case abi.ArrayTy: + return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs) + case abi.SliceTy: + return "[]" + bindTypeGo(*kind.Elem, structs) + default: + return bindBasicTypeGo(kind) + } +} + +// bindTopicType is a set of type binders that convert Solidity types to some +// supported programming language topic types. +var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ + LangGo: bindTopicTypeGo, +} + +// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same +// funcionality as for simple types, but dynamic types get converted to hashes. +func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { + bound := bindTypeGo(kind, structs) + + // todo(rjl493456442) according solidity documentation, indexed event + // parameters that are not value types i.e. arrays and structs are not + // stored directly but instead a keccak256-hash of an encoding is stored. + // + // We only convert stringS and bytes to hash, still need to deal with + // array(both fixed-size and dynamic-size) and struct. + if bound == "string" || bound == "[]byte" { + bound = "common.Hash" + } + return bound +} + +// bindStructType is a set of type binders that convert Solidity tuple types to some supported +// programming language struct definition. +var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ + LangGo: bindStructTypeGo, +} + +// bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping +// in the given map. +// Notably, this function will resolve and record nested struct recursively. +func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { + switch kind.T { + case abi.TupleTy: + // We compose raw struct name and canonical parameter expression + // together here. The reason is before solidity v0.5.11, kind.TupleRawName + // is empty, so we use canonical parameter expression to distinguish + // different struct definition. From the consideration of backward + // compatibility, we concat these two together so that if kind.TupleRawName + // is not empty, it can have unique id. + id := kind.TupleRawName + kind.String() + if s, exist := structs[id]; exist { + return s.Name + } + var fields []*tmplField + for i, elem := range kind.TupleElems { + field := bindStructTypeGo(*elem, structs) + fields = append(fields, &tmplField{Type: field, Name: capitalise(kind.TupleRawNames[i]), SolKind: *elem}) + } + name := kind.TupleRawName + if name == "" { + name = fmt.Sprintf("Struct%d", len(structs)) + } + structs[id] = &tmplStruct{ + Name: name, + Fields: fields, + } + return name + case abi.ArrayTy: + return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs) + case abi.SliceTy: + return "[]" + bindStructTypeGo(*kind.Elem, structs) + default: + return bindBasicTypeGo(kind) + } +} + +// namedType is a set of functions that transform language specific types to +// named versions that my be used inside method names. +var namedType = map[Lang]func(string, abi.Type) string{ + LangGo: func(string, abi.Type) string { panic("this shouldn't be needed") }, +} + +// alias returns an alias of the given string based on the aliasing rules +// or returns itself if no rule is matched. +func alias(aliases map[string]string, n string) string { + if alias, exist := aliases[n]; exist { + return alias + } + return n +} + +// methodNormalizer is a name transformer that modifies Solidity method names to +// conform to target language naming concentions. +var methodNormalizer = map[Lang]func(string) string{ + LangGo: abi.ToCamelCase, +} + +// capitalise makes a camel-case string which starts with an upper case character. +var capitalise = abi.ToCamelCase + +// decapitalise makes a camel-case string which starts with a lower case character. +func decapitalise(input string) string { + if len(input) == 0 { + return input + } + + goForm := abi.ToCamelCase(input) + return strings.ToLower(goForm[:1]) + goForm[1:] +} + +// structured checks whether a list of ABI data types has enough information to +// operate through a proper Go struct or if flat returns are needed. +func structured(args abi.Arguments) bool { + if len(args) < 2 { + return false + } + exists := make(map[string]bool) + for _, out := range args { + // If the name is anonymous, we can't organize into a struct + if out.Name == "" { + return false + } + // If the field name is empty when normalized or collides (var, Var, _var, _Var), + // we can't organize into a struct + field := capitalise(out.Name) + if field == "" || exists[field] { + return false + } + exists[field] = true + } + return true +} + +// hasStruct returns an indicator whether the given type is struct, struct slice +// or struct array. +func hasStruct(t abi.Type) bool { + switch t.T { + case abi.SliceTy: + return hasStruct(*t.Elem) + case abi.ArrayTy: + return hasStruct(*t.Elem) + case abi.TupleTy: + return true + default: + return false + } +} + +// resolveArgName converts a raw argument representation into a user friendly format. +func resolveArgName(arg abi.Argument, structs map[string]*tmplStruct) string { + var ( + prefix string + embedded string + typ = &arg.Type + ) +loop: + for { + switch typ.T { + case abi.SliceTy: + prefix += "[]" + case abi.ArrayTy: + prefix += fmt.Sprintf("[%d]", typ.Size) + default: + embedded = typ.TupleRawName + typ.String() + break loop + } + typ = typ.Elem + } + if s, exist := structs[embedded]; exist { + return prefix + s.Name + } else { + return arg.Type.String() + } +} + +// formatMethod transforms raw method representation into a user friendly one. +func formatMethod(method abi.Method, structs map[string]*tmplStruct) string { + inputs := make([]string, len(method.Inputs)) + for i, input := range method.Inputs { + inputs[i] = fmt.Sprintf("%v %v", resolveArgName(input, structs), input.Name) + } + outputs := make([]string, len(method.Outputs)) + for i, output := range method.Outputs { + outputs[i] = resolveArgName(output, structs) + if len(output.Name) > 0 { + outputs[i] += fmt.Sprintf(" %v", output.Name) + } + } + // Extract meaningful state mutability of solidity method. + // If it's default value, never print it. + state := method.StateMutability + if state == "nonpayable" { + state = "" + } + if state != "" { + state = state + " " + } + identity := fmt.Sprintf("function %v", method.RawName) + if method.Type == abi.Fallback { + identity = "fallback" + } else if method.Type == abi.Receive { + identity = "receive" + } + return fmt.Sprintf("%s(%v) %sreturns(%v)", identity, strings.Join(inputs, ", "), state, strings.Join(outputs, ", ")) +} + +// formatEvent transforms raw event representation into a user friendly one. +func formatEvent(event abi.Event, structs map[string]*tmplStruct) string { + inputs := make([]string, len(event.Inputs)) + for i, input := range event.Inputs { + if input.Indexed { + inputs[i] = fmt.Sprintf("%v indexed %v", resolveArgName(input, structs), input.Name) + } else { + inputs[i] = fmt.Sprintf("%v %v", resolveArgName(input, structs), input.Name) + } + } + return fmt.Sprintf("event %v(%v)", event.RawName, strings.Join(inputs, ", ")) +}

diff --git go-ethereum/accounts/abi/bind_v2/auth.go celo/accounts/abi/bind_v2/auth.go new file mode 100644 index 0000000000000000000000000000000000000000..ec4876d87fc80bed7f0f662aa46b4af327fb0e69 --- /dev/null +++ celo/accounts/abi/bind_v2/auth.go @@ -0,0 +1,182 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "crypto/ecdsa" + "errors" + "io" + "io/ioutil" + "math/big" + + "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/accounts/external" + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" +) + +// ErrNoChainID is returned whenever the user failed to specify a chain id. +var ErrNoChainID = errors.New("no chain id specified") + +// ErrNotAuthorized is returned when an account is not properly unlocked. +var ErrNotAuthorized = errors.New("not authorized to sign this account") + +// NewTransactor is a utility method to easily create a transaction signer from +// an encrypted json key stream and the associated passphrase. +// +// Deprecated: Use NewTransactorWithChainID instead. +func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) { + log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID") + json, err := ioutil.ReadAll(keyin) + if err != nil { + return nil, err + } + key, err := keystore.DecryptKey(json, passphrase) + if err != nil { + return nil, err + } + return NewKeyedTransactor(key.PrivateKey), nil +} + +// NewKeyStoreTransactor is a utility method to easily create a transaction signer from +// an decrypted key from a keystore +// +// Deprecated: Use NewKeyStoreTransactorWithChainID instead. +func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) { + log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID") + signer := types.LatestSignerForChainID(nil) + return &TransactOpts{ + From: account.Address, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != account.Address { + return nil, ErrNotAuthorized + } + signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes()) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + }, nil +} + +// NewKeyedTransactor is a utility method to easily create a transaction signer +// from a single private key. +// +// Deprecated: Use NewKeyedTransactorWithChainID instead. +func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts { + log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID") + keyAddr := crypto.PubkeyToAddress(key.PublicKey) + signer := types.LatestSignerForChainID(nil) + return &TransactOpts{ + From: keyAddr, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != keyAddr { + return nil, ErrNotAuthorized + } + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + } +} + +// NewTransactorWithChainID is a utility method to easily create a transaction signer from +// an encrypted json key stream and the associated passphrase. +func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error) { + json, err := ioutil.ReadAll(keyin) + if err != nil { + return nil, err + } + key, err := keystore.DecryptKey(json, passphrase) + if err != nil { + return nil, err + } + return NewKeyedTransactorWithChainID(key.PrivateKey, chainID) +} + +// NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from +// an decrypted key from a keystore. +// +// Deprecated: Use NewKeyedTransactorWithChainID instead. +func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) { + if chainID == nil { + return nil, ErrNoChainID + } + signer := types.LatestSignerForChainID(chainID) + return &TransactOpts{ + From: account.Address, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != account.Address { + return nil, ErrNotAuthorized + } + signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes()) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + }, nil +} + +// NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer +// from a single private key. +func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) { + keyAddr := crypto.PubkeyToAddress(key.PublicKey) + if chainID == nil { + return nil, ErrNoChainID + } + signer := types.LatestSignerForChainID(chainID) + return &TransactOpts{ + From: keyAddr, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + if address != keyAddr { + return nil, ErrNotAuthorized + } + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key) + if err != nil { + return nil, err + } + return tx.WithSignature(signer, signature) + }, + Context: context.Background(), + }, nil +} + +// NewClefTransactor is a utility method to easily create a transaction signer +// with a clef backend. +func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts { + return &TransactOpts{ + From: account.Address, + Signer: func(address common.Address, transaction *types.Transaction) (*types.Transaction, error) { + if address != account.Address { + return nil, errors.New("not authorized to sign this account") + } + return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id + }, + Context: context.Background(), + } +}

diff --git go-ethereum/accounts/abi/bind_v2/backend.go celo/accounts/abi/bind_v2/backend.go new file mode 100644 index 0000000000000000000000000000000000000000..817b3c36e53061dc982c5dcbf1317ef896b2e4d5 --- /dev/null +++ celo/accounts/abi/bind_v2/backend.go @@ -0,0 +1,128 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +var ( + // ErrNoCode is returned by call and transact operations for which the requested + // recipient contract to operate on does not exist in the state db or does not + // have any code associated with it (i.e. suicided). + ErrNoCode = errors.New("no contract code at given address") + + // ErrNoPendingState is raised when attempting to perform a pending state action + // on a backend that doesn't implement PendingContractCaller. + ErrNoPendingState = errors.New("backend does not support pending state") + + // ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves + // an empty contract behind. + ErrNoCodeAfterDeploy = errors.New("no contract code after deployment") +) + +// ContractCaller defines the methods needed to allow operating with contract on a read +// only basis. +type ContractCaller interface { + // CodeAt returns the code of the given account. This is needed to differentiate + // between contract internal errors and the local chain being out of sync. + CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) + + // ContractCall executes an Ethereum contract call with the specified data as the + // input. + CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) +} + +// PendingContractCaller defines methods to perform contract calls on the pending state. +// Call will try to discover this interface when access to the pending state is requested. +// If the backend does not support the pending state, Call returns ErrNoPendingState. +type PendingContractCaller interface { + // PendingCodeAt returns the code of the given account in the pending state. + PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) + + // PendingCallContract executes an Ethereum contract call against the pending state. + PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) +} + +// ContractTransactor defines the methods needed to allow operating with contract +// on a write only basis. Beside the transacting method, the remainder are helpers +// used when the user does not provide some needed values, but rather leaves it up +// to the transactor to decide. +type ContractTransactor interface { + // HeaderByNumber returns a block header from the current canonical chain. If + // number is nil, the latest known header is returned. + HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) + + // PendingCodeAt returns the code of the given account in the pending state. + PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) + + // PendingNonceAt retrieves the current pending nonce associated with an account. + PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) + + // SuggestGasPrice retrieves the currently suggested gas price to allow a timely + // execution of a transaction. + SuggestGasPrice(ctx context.Context) (*big.Int, error) + + // SuggestGasTipCap retrieves the currently suggested 1559 priority fee to allow + // a timely execution of a transaction. + SuggestGasTipCap(ctx context.Context) (*big.Int, error) + + // EstimateGas tries to estimate the gas needed to execute a specific + // transaction based on the current pending state of the backend blockchain. + // There is no guarantee that this is the true gas limit requirement as other + // transactions may be added or removed by miners, but it should provide a basis + // for setting a reasonable default. + EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) + + // SendTransaction injects the transaction into the pending pool for execution. + SendTransaction(ctx context.Context, tx *types.Transaction) error + + TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) +} + +// ContractFilterer defines the methods needed to access log events using one-off +// queries or continuous event subscriptions. +type ContractFilterer interface { + // FilterLogs executes a log filter operation, blocking during execution and + // returning all the results in one batch. + // + // TODO(karalabe): Deprecate when the subscription one can return past data too. + FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) + + // SubscribeFilterLogs creates a background log filtering operation, returning + // a subscription immediately, which can be used to stream the found events. + SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) +} + +// DeployBackend wraps the operations needed by WaitMined and WaitDeployed. +type DeployBackend interface { + TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) + CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) +} + +// ContractBackend defines the methods needed to work with contracts on a read-write basis. +type ContractBackend interface { + ContractCaller + ContractTransactor + ContractFilterer +}

diff --git go-ethereum/accounts/abi/bind_v2/base.go celo/accounts/abi/bind_v2/base.go new file mode 100644 index 0000000000000000000000000000000000000000..462fe0d90e71931517ae5afb094baad9101defd8 --- /dev/null +++ celo/accounts/abi/bind_v2/base.go @@ -0,0 +1,609 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "errors" + "fmt" + "math/big" + "strings" + "sync" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/event" +) + +// SignerFn is a signer function callback when a contract requires a method to +// sign the transaction before submission. +type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error) + +// CallOpts is the collection of options to fine tune a contract call request. +type CallOpts struct { + Pending bool // Whether to operate on the pending state or the last known one + From common.Address // Optional the sender address, otherwise the first account is used + BlockNumber *big.Int // Optional the block number on which the call should be performed + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// TransactOpts is the collection of authorization data required to create a +// valid Ethereum transaction. +type TransactOpts struct { + From common.Address // Ethereum account to send the transaction from + Nonce *big.Int // Nonce to use for the transaction execution (nil = use pending state) + Signer SignerFn // Method to use for signing the transaction (mandatory) + ChainID *big.Int // Chain/network id for use for replay protection during signing (nil = no replay protection) + + Value *big.Int // Funds to transfer along along the transaction (nil = 0 = no funds) + GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) + FeeCurrency *common.Address // Fee currency to be used for transaction (nil = default currency = Celo Gold) + GatewayFeeRecipient *common.Address // Address to which gateway fees should be paid (nil = no gateway fees are paid) + GatewayFee *big.Int // Value of gateway fees to be paid (nil = no gateway fees are paid) + GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) + GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) + GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) + + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// FilterOpts is the collection of options to fine tune filtering for events +// within a bound contract. +type FilterOpts struct { + Start uint64 // Start of the queried range + End *uint64 // End of the range (nil = latest) + + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// WatchOpts is the collection of options to fine tune subscribing for events +// within a bound contract. +type WatchOpts struct { + Start *uint64 // Start of the queried range (nil = latest) + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// MetaData collects all metadata for a bound contract. +type MetaData struct { + mu sync.Mutex + Sigs map[string]string + Bin string + ABI string + ab *abi.ABI +} + +func (m *MetaData) GetAbi() (*abi.ABI, error) { + m.mu.Lock() + defer m.mu.Unlock() + if m.ab != nil { + return m.ab, nil + } + if parsed, err := abi.JSON(strings.NewReader(m.ABI)); err != nil { + return nil, err + } else { + m.ab = &parsed + } + return m.ab, nil +} + +// BoundContract is the base wrapper object that reflects a contract on the +// Ethereum network. It contains a collection of methods that are used by the +// higher level contract bindings to operate. +type BoundContract struct { + address common.Address // Deployment address of the contract on the Ethereum blockchain + abi abi.ABI // Reflect based ABI to access the correct Ethereum methods + backend ContractBackend // Event filtering to interact with the blockchain +} + +// NewBoundContract creates a low level contract interface through which calls +// and transactions may be made through. +func NewBoundContract(address common.Address, abi abi.ABI, backend ContractBackend) *BoundContract { + return &BoundContract{ + address: address, + abi: abi, + backend: backend, + } +} + +// DeployContract deploys a contract onto the Ethereum blockchain and binds the +// deployment address with a Go wrapper. +func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) { + // Otherwise try to deploy the contract + c := NewBoundContract(common.Address{}, abi, backend) + + input, err := c.abi.Pack("", params...) + if err != nil { + return common.Address{}, nil, nil, err + } + tx, err := c.transact(opts, nil, append(bytecode, input...)) + if err != nil { + return common.Address{}, nil, nil, err + } + c.address = crypto.CreateAddress(opts.From, tx.Nonce()) + return c.address, tx, c, nil +} + +// ABI returns the bound contract parsed ABI +func (c *BoundContract) ABI() abi.ABI { + return c.abi +} + +// TxObj returns an obj that can be used to get the transaction, send it, estimate it +func (c *BoundContract) TxObj(opts *TransactOpts, method string, params ...interface{}) *TxObject { + return &TxObject{ + method: method, + params: params, + opts: opts, + c: c, + } +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error { + // Don't crash on a lazy user + if opts == nil { + opts = new(CallOpts) + } + if results == nil { + results = new([]interface{}) + } + // Pack the input, call and unpack the results + input, err := c.abi.Pack(method, params...) + if err != nil { + return err + } + var ( + msg = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input} + ctx = ensureContext(opts.Context) + code []byte + output []byte + ) + if opts.Pending { + pb, ok := c.backend.(PendingContractCaller) + if !ok { + return ErrNoPendingState + } + output, err = pb.PendingCallContract(ctx, msg) + if err == nil && len(output) == 0 { + // Make sure we have a contract to operate on, and bail out otherwise. + if code, err = pb.PendingCodeAt(ctx, c.address); err != nil { + return err + } else if len(code) == 0 { + return ErrNoCode + } + } + } else { + output, err = c.backend.CallContract(ctx, msg, opts.BlockNumber) + if err != nil { + return err + } + if len(output) == 0 { + // Make sure we have a contract to operate on, and bail out otherwise. + if code, err = c.backend.CodeAt(ctx, c.address, opts.BlockNumber); err != nil { + return err + } else if len(code) == 0 { + return ErrNoCode + } + } + } + + if len(*results) == 0 { + res, err := c.abi.Unpack(method, output) + *results = res + return err + } + res := *results + return c.abi.UnpackIntoInterface(res[0], method, output) +} + +// Transact invokes the (paid) contract method with params as input values. +func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + // Otherwise pack up the parameters and invoke the contract + input, err := c.abi.Pack(method, params...) + if err != nil { + return nil, err + } + // todo(rjl493456442) check the method is payable or not, + // reject invalid transaction at the first place + return c.transact(opts, &c.address, input) +} + +// TransactionFor returns the signed transaction for the contract method with params as input values +func (c *BoundContract) TransactionFor(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + // Otherwise pack up the parameters and invoke the contract + input, err := c.abi.Pack(method, params...) + if err != nil { + return nil, err + } + // todo(rjl493456442) check the method is payable or not, + // reject invalid transaction at the first place + return c.transactionFor(opts, &c.address, input) +} + +// EstimateGas obtains an estimate for calling contract method with params as input values. +func (c *BoundContract) EstimateGas(opts *TransactOpts, method string, params ...interface{}) (uint64, error) { + // Otherwise pack up the parameters and invoke the contract + input, err := c.abi.Pack(method, params...) + if err != nil { + return 0, err + } + + msg := ethereum.CallMsg{From: opts.From, To: &c.address, GasPrice: opts.GasPrice, Value: opts.Value, Data: input} + gasLimit, err := c.backend.EstimateGas(ensureContext(opts.Context), msg) + if err != nil { + return 0, err + } + + // Apply buffer 3/2 => 1.5 => +50% (weird way of doing it, thanks go) + gasLimit = new(big.Int).Div(new(big.Int).Mul(new(big.Int).SetUint64(gasLimit), big.NewInt(3)), big.NewInt(2)).Uint64() + + return gasLimit, nil +} + +// RawTransact initiates a transaction with the given raw calldata as the input. +// It's usually used to initiates transaction for invoking **Fallback** function. +func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) { + // todo(rjl493456442) check the method is payable or not, + // reject invalid transaction at the first place + return c.transact(opts, &c.address, calldata) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error) { + // todo(rjl493456442) check the payable fallback or receive is defined + // or not, reject invalid transaction at the first place + return c.transact(opts, &c.address, nil) +} + +func (c *BoundContract) transactionFor(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) { + var err error + + // Ensure a valid value field and resolve the account nonce + value := opts.Value + if value == nil { + value = new(big.Int) + } + var nonce uint64 + if opts.Nonce == nil { + nonce, err = c.backend.PendingNonceAt(ensureContext(opts.Context), opts.From) + if err != nil { + return nil, fmt.Errorf("failed to retrieve account nonce: %v", err) + } + } else { + nonce = opts.Nonce.Uint64() + } + // Figure out reasonable gas price values + if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) { + return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") + } + // head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil) + // if err != nil { + // return nil, err + // } + // TODO: Use GPM here + // if head.BaseFee != nil && opts.GasPrice == nil { + // if opts.GasTipCap == nil { + // tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context)) + // if err != nil { + // return nil, err + // } + // opts.GasTipCap = tip + // } + // if opts.GasFeeCap == nil { + // gasFeeCap := new(big.Int).Add( + // opts.GasTipCap, + // new(big.Int).Mul(head.BaseFee, big.NewInt(2)), + // ) + // opts.GasFeeCap = gasFeeCap + // } + // if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 { + // return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap) + // } + // } else { + if opts.GasFeeCap != nil || opts.GasTipCap != nil { + return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") + } + if opts.GasPrice == nil { + price, err := c.backend.SuggestGasPrice(ensureContext(opts.Context)) + if err != nil { + return nil, err + } + opts.GasPrice = price + } + // } + + feeCurrency := opts.FeeCurrency + // TODO(nategraf): Add SuggestFeeCurrency to Transactor to get fee currency + // Otherwise, the user might not be able to pay in non-native currency for contract + // deployment. Paying for Contract deployment in non-native currency might not work right now. + // Only paying for token transfer in non-native currency is supported. + //if feeCurrency == 0 { + // feeCurrency = c.backend.SuggestFeeCurrency(opts.Context) + //} + + gatewayFeeRecipient := opts.GatewayFeeRecipient + gatewayFee := opts.GatewayFee + // TODO(nategraf): Add SuggestGatewayFee to Transactor. + + gasLimit := opts.GasLimit + if gasLimit == 0 { + // Gas estimation cannot succeed without code for method invocations + if contract != nil { + if code, err := c.backend.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil { + return nil, err + } else if len(code) == 0 { + return nil, ErrNoCode + } + } + // If the contract surely has code (or code is not needed), estimate the transaction + msg := ethereum.CallMsg{ + From: opts.From, + To: contract, + GasPrice: opts.GasPrice, + GasTipCap: opts.GasTipCap, + GasFeeCap: opts.GasFeeCap, + Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, + Data: input, + } + gasLimit, err = c.backend.EstimateGas(ensureContext(opts.Context), msg) + if err != nil { + return nil, fmt.Errorf("failed to estimate gas needed: %v", err) + } + + // Apply buffer 3/2 => 1.5 => +50% (weird way of doing it, thanks go) + gasLimit = new(big.Int).Div(new(big.Int).Mul(new(big.Int).SetUint64(gasLimit), big.NewInt(3)), big.NewInt(2)).Uint64() + } + // Create the transaction, sign it and schedule it for execution + var rawTx *types.Transaction + if opts.GasFeeCap == nil { + baseTx := &types.LegacyTx{ + Nonce: nonce, + GasPrice: opts.GasPrice, + Gas: gasLimit, + Value: value, + FeeCurrency: feeCurrency, + GatewayFeeRecipient: gatewayFeeRecipient, + GatewayFee: gatewayFee, + Data: input, + } + if contract != nil { + baseTx.To = &c.address + } + rawTx = types.NewTx(baseTx) + } else { + baseTx := &types.DynamicFeeTx{ + Nonce: nonce, + GasFeeCap: opts.GasFeeCap, + GasTipCap: opts.GasTipCap, + Gas: gasLimit, + Value: value, + Data: input, + } + if contract != nil { + baseTx.To = &c.address + } + rawTx = types.NewTx(baseTx) + } + if opts.Signer == nil { + return nil, errors.New("no signer to authorize the transaction with") + } + signedTx, err := opts.Signer(opts.From, rawTx) + if err != nil { + return nil, err + } + + return signedTx, err +} + +// transact executes an actual transaction invocation, first deriving any missing +// authorization fields, and then scheduling the transaction for execution. +func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) { + var err error + + signedTx, err := c.transactionFor(opts, contract, input) + if err != nil { + return nil, err + } + + if err := c.backend.SendTransaction(ensureContext(opts.Context), signedTx); err != nil { + return nil, err + } + return signedTx, nil +} + +// LogEventName will verify the log belongs to the contract and return the eventName for it +func (c *BoundContract) LogEventName(log types.Log) (eventName string, ok bool, err error) { + if log.Address != c.address || len(log.Topics) < 1 { + return "", false, err + } + + event, err := c.abi.EventByID(log.Topics[0]) + if err != nil { + return "", false, err + } + return event.Name, true, nil +} + +// FilterLogs filters contract logs for past blocks, returning the necessary +// channels to construct a strongly typed bound iterator on top of them. +func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(FilterOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) + + topics, err := abi.MakeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{c.address}, + Topics: topics, + FromBlock: new(big.Int).SetUint64(opts.Start), + } + if opts.End != nil { + config.ToBlock = new(big.Int).SetUint64(*opts.End) + } + /* TODO(karalabe): Replace the rest of the method below with this when supported + sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + */ + buff, err := c.backend.FilterLogs(ensureContext(opts.Context), config) + if err != nil { + return nil, nil, err + } + sub, err := event.NewSubscription(func(quit <-chan struct{}) error { + for _, log := range buff { + select { + case logs <- log: + case <-quit: + return nil + } + } + return nil + }), nil + + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +// WatchLogs filters subscribes to contract logs for future blocks, returning a +// subscription object that can be used to tear down the watcher. +func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(WatchOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) + + topics, err := abi.MakeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{c.address}, + Topics: topics, + } + if opts.Start != nil { + config.FromBlock = new(big.Int).SetUint64(*opts.Start) + } + sub, err := c.backend.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +// UnpackLog unpacks a retrieved log into the provided output structure. +func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error { + if log.Topics[0] != c.abi.Events[event].ID { + return fmt.Errorf("event signature mismatch") + } + if len(log.Data) > 0 { + if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return err + } + } + var indexed abi.Arguments + for _, arg := range c.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + return abi.ParseTopics(out, indexed, log.Topics[1:]) +} + +// UnpackLogIntoMap unpacks a retrieved log into the provided map. +func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error { + if log.Topics[0] != c.abi.Events[event].ID { + return fmt.Errorf("event signature mismatch") + } + if len(log.Data) > 0 { + if err := c.abi.UnpackIntoMap(out, event, log.Data); err != nil { + return err + } + } + var indexed abi.Arguments + for _, arg := range c.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + return abi.ParseTopicsIntoMap(out, indexed, log.Topics[1:]) +} + +// ensureContext is a helper method to ensure a context is not nil, even if the +// user specified it as such. +func ensureContext(ctx context.Context) context.Context { + if ctx == nil { + return context.Background() + } + return ctx +} + +type TxPromise struct { + Transaction *types.Transaction + backend ContractBackend +} + +func (txp *TxPromise) WaitMined(ctx context.Context) (*types.Receipt, error) { + return WaitMined(ctx, txp.backend, txp.Transaction) +} + +type TxObject struct { + method string + params []interface{} + opts *TransactOpts + c *BoundContract +} + +func (txo *TxObject) Send() (*TxPromise, error) { + tx, err := txo.c.Transact(txo.opts, txo.method, txo.params...) + + return &TxPromise{ + Transaction: tx, + backend: txo.c.backend, + }, err +} + +func (txo *TxObject) EstimateGas() (uint64, error) { + return txo.c.EstimateGas(txo.opts, txo.method, txo.params...) +} + +func (txo *TxObject) Transaction() (*types.Transaction, error) { + return txo.c.TransactionFor(txo.opts, txo.method, txo.params...) +}

diff --git go-ethereum/accounts/abi/bind_v2/util_test.go celo/accounts/abi/bind_v2/util_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5b36290e60a8daa7125535c1a9b30648f0242183 --- /dev/null +++ celo/accounts/abi/bind_v2/util_test.go @@ -0,0 +1,135 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "errors" + "math/big" + "testing" + "time" + + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" +) + +var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + +var genericBaseFee = big.NewInt(2) // set a constant gas price to be above the GPM. + +var waitDeployedTests = map[string]struct { + code string + gas uint64 + wantAddress common.Address + wantErr error +}{ + "successful deploy": { + code: `6060604052600a8060106000396000f360606040526008565b00`, + gas: 3000000, + wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), + }, + "empty code": { + code: ``, + gas: 300000, + wantErr: bind.ErrNoCodeAfterDeploy, + wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), + }, +} + +func TestWaitDeployed(t *testing.T) { + for name, test := range waitDeployedTests { + backend := backends.NewSimulatedBackend( + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) + defer backend.Close() + + // Create the transaction + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1)) + + tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, nil, nil, nil, common.FromHex(test.code)) + tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) + + // Wait for it to get mined in the background. + var ( + err error + address common.Address + mined = make(chan struct{}) + ctx = context.Background() + ) + go func() { + address, err = bind.WaitDeployed(ctx, backend, tx) + close(mined) + }() + + // Send and mine the transaction. + backend.SendTransaction(ctx, tx) + backend.Commit() + + select { + case <-mined: + if err != test.wantErr { + t.Errorf("test %q: error mismatch: got %q, want %q", name, err, test.wantErr) + } + if address != test.wantAddress { + t.Errorf("test %q: unexpected contract address %s", name, address.Hex()) + } + case <-time.After(2 * time.Second): + t.Errorf("test %q: timeout", name) + } + } +} + +func TestWaitDeployedCornerCases(t *testing.T) { + backend := backends.NewSimulatedBackend( + core.GenesisAlloc{crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}}) + defer backend.Close() + + // head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough + gasPrice := new(big.Int).Add(genericBaseFee, big.NewInt(1)) + + // Create a transaction to an account. + code := "6060604052600a8060106000396000f360606040526008565b00" + tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, + gasPrice, nil, nil, nil, common.FromHex(code)) + tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + backend.SendTransaction(ctx, tx) + backend.Commit() + notContentCreation := errors.New("tx is not contract creation") + if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() { + t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err) + } + + // Create a transaction that is not mined. + tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, nil, nil, nil, common.FromHex(code)) + tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey) + + go func() { + contextCanceled := errors.New("context canceled") + if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() { + t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err) + } + }() + + backend.SendTransaction(ctx, tx) + cancel() +}

diff --git go-ethereum/accounts/abi/bind_v2/util.go celo/accounts/abi/bind_v2/util.go new file mode 100644 index 0000000000000000000000000000000000000000..c9d60fc101fa6d491c4f84bbbd38fba1cb76d214 --- /dev/null +++ celo/accounts/abi/bind_v2/util.go @@ -0,0 +1,76 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import ( + "context" + "fmt" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" +) + +// WaitMined waits for tx to be mined on the blockchain. +// It stops waiting when the context is canceled. +func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error) { + queryTicker := time.NewTicker(time.Second) + defer queryTicker.Stop() + + logger := log.New("hash", tx.Hash()) + for { + receipt, err := b.TransactionReceipt(ctx, tx.Hash()) + if receipt != nil { + return receipt, nil + } + if err != nil { + logger.Trace("Receipt retrieval failed", "err", err) + } else { + logger.Trace("Transaction not yet mined") + } + // Wait for the next round. + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-queryTicker.C: + } + } +} + +// WaitDeployed waits for a contract deployment transaction and returns the on-chain +// contract address when it is mined. It stops waiting when ctx is canceled. +func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) { + if tx.To() != nil { + return common.Address{}, fmt.Errorf("tx is not contract creation") + } + receipt, err := WaitMined(ctx, b, tx) + if err != nil { + return common.Address{}, err + } + if receipt.ContractAddress == (common.Address{}) { + return common.Address{}, fmt.Errorf("zero address") + } + // Check that code has indeed been deployed at the address. + // This matters on pre-Homestead chains: OOG in the constructor + // could leave an empty account behind. + code, err := b.CodeAt(ctx, receipt.ContractAddress, nil) + if err == nil && len(code) == 0 { + err = ErrNoCodeAfterDeploy + } + return receipt.ContractAddress, err +}

diff --git go-ethereum/accounts/abi/bind_v2/template.go celo/accounts/abi/bind_v2/template.go new file mode 100644 index 0000000000000000000000000000000000000000..93a4651d751f9543dfdd9382a71273e574f99ccd --- /dev/null +++ celo/accounts/abi/bind_v2/template.go @@ -0,0 +1,497 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package bind_v2 + +import "github.com/ethereum/go-ethereum/accounts/abi" + +// tmplData is the data structure required to fill the binding template. +type tmplData struct { + Package string // Name of the package to place the generated file in + Contracts map[string]*tmplContract // List of contracts to generate into this file + Libraries map[string]string // Map the bytecode's link pattern to the library name + Structs map[string]*tmplStruct // Contract struct type definitions +} + +// tmplContract contains the data needed to generate an individual contract binding. +type tmplContract struct { + Type string // Type name of the main contract binding + InputABI string // JSON ABI used as the input to generate the binding from + InputBin string // Optional EVM bytecode used to denetare deploy code from + FuncSigs map[string]string // Optional map: string signature -> 4-byte signature + Constructor abi.Method // Contract constructor for deploy parametrization + Calls map[string]*tmplMethod // Contract calls that only read state data + Transacts map[string]*tmplMethod // Contract calls that write state data + Fallback *tmplMethod // Additional special fallback function + Receive *tmplMethod // Additional special receive function + Events map[string]*tmplEvent // Contract events accessors + Libraries map[string]string // Same as tmplData, but filtered to only keep what the contract needs + Library bool // Indicator whether the contract is a library +} + +// tmplMethod is a wrapper around an abi.Method that contains a few preprocessed +// and cached data fields. +type tmplMethod struct { + Original abi.Method // Original method as parsed by the abi package + Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns) + Structured bool // Whether the returns should be accumulated into a struct +} + +// tmplEvent is a wrapper around an abi.Event that contains a few preprocessed +// and cached data fields. +type tmplEvent struct { + Original abi.Event // Original event as parsed by the abi package + Normalized abi.Event // Normalized version of the parsed fields +} + +// tmplField is a wrapper around a struct field with binding language +// struct type definition and relative filed name. +type tmplField struct { + Type string // Field type representation depends on target binding language + Name string // Field name converted from the raw user-defined field name + SolKind abi.Type // Raw abi type information +} + +// tmplStruct is a wrapper around an abi.tuple contains a auto-generated +// struct name. +type tmplStruct struct { + Name string // Auto-generated struct name(before solidity v0.5.11) or raw name. + Fields []*tmplField // Struct fields definition depends on the binding language. +} + +// tmplSource is language to template mapping containing all the supported +// programming languages the package can generate to. +var tmplSource = map[Lang]string{ + LangGo: tmplSourceGo, +} + +// tmplSourceGo is the Go source template use to generate the contract binding +// based on. +const tmplSourceGo = ` +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package {{.Package}} + +import ( + "math/big" + "strings" + "errors" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + bind "github.com/ethereum/go-ethereum/accounts/abi/bind_v2" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +{{$structs := .Structs}} +{{range $structs}} + // {{.Name}} is an auto generated low-level Go binding around an user-defined struct. + type {{.Name}} struct { + {{range $field := .Fields}} + {{$field.Name}} {{$field.Type}}{{end}} + } +{{end}} + +{{range $contract := .Contracts}} + // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. + var {{.Type}}MetaData = &bind.MetaData{ + ABI: "{{.InputABI}}", + {{if $contract.FuncSigs -}} + Sigs: map[string]string{ + {{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}", + {{end}} + }, + {{end -}} + {{if .InputBin -}} + Bin: "0x{{.InputBin}}", + {{end}} + } + // {{.Type}}ABI is the input ABI used to generate the binding from. + // Deprecated: Use {{.Type}}MetaData.ABI instead. + var {{.Type}}ABI = {{.Type}}MetaData.ABI + + {{if $contract.FuncSigs}} + // Deprecated: Use {{.Type}}MetaData.Sigs instead. + // {{.Type}}FuncSigs maps the 4-byte function signature to its string representation. + var {{.Type}}FuncSigs = {{.Type}}MetaData.Sigs + {{end}} + + {{if .InputBin}} + // {{.Type}}Bin is the compiled bytecode used for deploying new contracts. + // Deprecated: Use {{.Type}}MetaData.Bin instead. + var {{.Type}}Bin = {{.Type}}MetaData.Bin + + // Deploy{{.Type}} deploys a new Ethereum contract, binding an instance of {{.Type}} to it. + func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) { + parsed, err := {{.Type}}MetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + {{range $pattern, $name := .Libraries}} + {{decapitalise $name}}Addr, _, _, _ := Deploy{{capitalise $name}}(auth, backend) + {{$contract.Type}}Bin = strings.Replace({{$contract.Type}}Bin, "__${{$pattern}}$__", {{decapitalise $name}}Addr.String()[2:], -1) + {{end}} + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex({{.Type}}Bin), backend {{range .Constructor.Inputs}}, {{.Name}}{{end}}) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &{{.Type}}{ contract: contract }, nil + } + {{end}} + + // {{.Type}} is an auto generated Go binding around an Ethereum contract. + type {{.Type}} struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls + } + + // {{.Type}}Session is an auto generated Go binding around an Ethereum contract, + // with pre-set call and transact options. + type {{.Type}}Session struct { + Contract *{{.Type}} // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session + } + + + // {{.Type}}Raw is an auto generated low-level Go binding around an Ethereum contract. + type {{.Type}}Raw struct { + Contract *{{.Type}} // Generic contract binding to access the raw methods on + } + + // New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract. + func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) { + contract, err := bind{{.Type}}(address, backend) + if err != nil { + return nil, err + } + return &{{.Type}}{ contract: contract }, nil + } + + // bind{{.Type}} binds a generic wrapper to an already deployed contract. + func bind{{.Type}}(address common.Address, contract bind.ContractBackend) (*bind.BoundContract, error) { + parsed, err := Parse{{.Type}}ABI() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, contract), nil + } + + // Parse{{.Type}}ABI parses the ABI + func Parse{{.Type}}ABI() (*abi.ABI, error) { + parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) + if err != nil { + return nil, err + } + return &parsed, nil + } + + // Call invokes the (constant) contract method with params as input values and + // sets the output to result. The result type might be a single field for simple + // returns, a slice of interfaces for anonymous returns and a struct for named + // returns. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...) + } + + // Transfer initiates a plain transaction to move funds to the contract, calling + // its default method if one is available. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.contract.Transfer(opts) + } + + // Transact invokes the (paid) contract method with params as input values. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.contract.Transact(opts, method, params...) + } + + // TxObj returns an obj that can be used to get the transaction, send it, estimate it. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) TxObj(opts *bind.TransactOpts, method string, params ...interface{}) *bind.TxObject { + return _{{$contract.Type}}.Contract.contract.TxObj(opts, method, params...) + } + + // EstimateGas obtains an estimate for calling contract method with params as input values. + func (_{{$contract.Type}} *{{$contract.Type}}Raw) EstimateGas(opts *bind.TransactOpts, method string, params ...interface{}) (uint64, error) { + return _{{$contract.Type}}.Contract.contract.EstimateGas(opts, method, params...) + } + + {{range .Calls}} + // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { + var out []interface{} + err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + {{if .Structured}} + outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} }) + if err != nil { + return *outstruct, err + } + {{range $i, $t := .Normalized.Outputs}} + outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + + return *outstruct, err + {{else}} + if err != nil { + return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err + } + {{range $i, $t := .Normalized.Outputs}} + out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + + return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err + {{end}} + } + + // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) { + return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + {{end}} + + {{range .Transacts}} + // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) *bind.TxObject { + return _{{$contract.Type}}.contract.TxObj(opts, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + // {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) *bind.TxObject { + return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + {{end}} + + // TryParseLog attempts to parse a log. Returns the parsed log, evenName and whether it was succesfull + func (_{{$contract.Type}} *{{$contract.Type}}) TryParseLog(log types.Log) (eventName string, event interface{}, ok bool, err error) { + eventName, ok, err = _{{$contract.Type}}.contract.LogEventName(log) + if err != nil || !ok { + return "", nil, false, err + } + + switch eventName { {{range .Events}} + case "{{.Normalized.Name}}": + event, err = _{{$contract.Type}}.Parse{{.Normalized.Name}}(log){{end}} + } + if err != nil { + return "", nil, false, err + } + + return eventName, event, ok, nil + } + + {{if .Fallback}} + // Fallback is a paid mutator transaction binding the contract fallback function. + // + // Solidity: {{.Fallback.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) { + return _{{$contract.Type}}.contract.RawTransact(opts, calldata) + } + + // Fallback is a paid mutator transaction binding the contract fallback function. + // + // Solidity: {{.Fallback.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata) + } + + {{end}} + + {{if .Receive}} + // Receive is a paid mutator transaction binding the contract receive function. + // + // Solidity: {{.Receive.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _{{$contract.Type}}.contract.RawTransact(opts, nil) // calldata is disallowed for receive function + } + + // Receive is a paid mutator transaction binding the contract receive function. + // + // Solidity: {{.Receive.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) { + return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts) + } + + {{end}} + + {{range .Events}} + // {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}}Iterator struct { + Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration + } + // Next advances the iterator to the subsequent event, returning whether there + // are any more events found. In case of a retrieval or parsing error, false is + // returned and Error() can be queried for the exact failure. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool { + // If the iterator failed, stop iterating + if (it.fail != nil) { + return false + } + // If the iterator completed, deliver directly whatever's available + if (it.done) { + select { + case log := <-it.logs: + it.Event = new({{$contract.Type}}{{.Normalized.Name}}) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new({{$contract.Type}}{{.Normalized.Name}}) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } + } + // Error returns any retrieval or parsing error occurred during filtering. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error { + return it.fail + } + // Close terminates the iteration process, releasing any pending underlying + // resources. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error { + it.sub.Unsubscribe() + return nil + } + + // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} + {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}} + Raw types.Log // Blockchain specific contextual infos + } + + // Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) { + {{range .Normalized.Inputs}} + {{if .Indexed}}var {{.Name}}Rule []interface{} + for _, {{.Name}}Item := range {{.Name}} { + {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item) + }{{end}}{{end}} + + logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}}) + if err != nil { + return nil, err + } + return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil + } + + // Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (event.Subscription, error) { + {{range .Normalized.Inputs}} + {{if .Indexed}}var {{.Name}}Rule []interface{} + for _, {{.Name}}Item := range {{.Name}} { + {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item) + }{{end}}{{end}} + + logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}}) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new({{$contract.Type}}{{.Normalized.Name}}) + if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil + } + + // Parse{{.Normalized.Name}} is a log parse operation binding the contract event 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Parse{{.Normalized.Name}}(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { + event := new({{$contract.Type}}{{.Normalized.Name}}) + if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil + } + + {{end}} +{{end}} +`

diff --git go-ethereum/accounts/scwallet/apdu.go celo/accounts/scwallet/apdu.go deleted file mode 100644 index 32b63edeb1fce2d29926739bf3926de440ea8e81..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/apdu.go +++ /dev/null @@ -1,87 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package scwallet - -import ( - "bytes" - "encoding/binary" - "fmt" -) - -// commandAPDU represents an application data unit sent to a smartcard. -type commandAPDU struct { - Cla, Ins, P1, P2 uint8 // Class, Instruction, Parameter 1, Parameter 2 - Data []byte // Command data - Le uint8 // Command data length -} - -// serialize serializes a command APDU. -func (ca commandAPDU) serialize() ([]byte, error) { - buf := new(bytes.Buffer) - - if err := binary.Write(buf, binary.BigEndian, ca.Cla); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.Ins); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.P1); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.P2); err != nil { - return nil, err - } - if len(ca.Data) > 0 { - if err := binary.Write(buf, binary.BigEndian, uint8(len(ca.Data))); err != nil { - return nil, err - } - if err := binary.Write(buf, binary.BigEndian, ca.Data); err != nil { - return nil, err - } - } - if err := binary.Write(buf, binary.BigEndian, ca.Le); err != nil { - return nil, err - } - return buf.Bytes(), nil -} - -// responseAPDU represents an application data unit received from a smart card. -type responseAPDU struct { - Data []byte // response data - Sw1, Sw2 uint8 // status words 1 and 2 -} - -// deserialize deserializes a response APDU. -func (ra *responseAPDU) deserialize(data []byte) error { - if len(data) < 2 { - return fmt.Errorf("can not deserialize data: payload too short (%d < 2)", len(data)) - } - - ra.Data = make([]byte, len(data)-2) - - buf := bytes.NewReader(data) - if err := binary.Read(buf, binary.BigEndian, &ra.Data); err != nil { - return err - } - if err := binary.Read(buf, binary.BigEndian, &ra.Sw1); err != nil { - return err - } - if err := binary.Read(buf, binary.BigEndian, &ra.Sw2); err != nil { - return err - } - return nil -}

diff --git go-ethereum/accounts/scwallet/README.md celo/accounts/scwallet/README.md deleted file mode 100644 index 4313d9c6b2f8ecacf53657409572f53e482bbbe4..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/README.md +++ /dev/null @@ -1,106 +0,0 @@ -# Using the smartcard wallet - -## Requirements - - * A USB smartcard reader - * A keycard that supports the status app - * PCSCD version 4.3 running on your system **Only version 4.3 is currently supported** - -## Preparing the smartcard - - **WARNING: FOILLOWING THESE INSTRUCTIONS WILL DESTROY THE MASTER KEY ON YOUR CARD. ONLY PROCEED IF NO FUNDS ARE ASSOCIATED WITH THESE ACCOUNTS** - - You can use status' [keycard-cli](https://github.com/status-im/keycard-cli) and you should get _at least_ version 2.1.1 of their [smartcard application](https://github.com/status-im/status-keycard/releases/download/2.2.1/keycard_v2.2.1.cap) - - You also need to make sure that the PCSC daemon is running on your system. - - Then, you can install the application to the card by typing: - - ``` - keycard install -a keycard_v2.2.1.cap && keycard init - ``` - - At the end of this process, you will be provided with a PIN, a PUK and a pairing password. Write them down, you'll need them shortly. - - Start `geth` with the `console` command. You will notice the following warning: - - ``` - WARN [04-09|16:58:38.898] Failed to open wallet url=keycard://044def09 err="smartcard: pairing password needed" - ``` - - Write down the URL (`keycard://044def09` in this example). Then ask `geth` to open the wallet: - - ``` - > personal.openWallet("keycard://044def09", "pairing password") - ``` - - The pairing password has been generated during the card initialization process. - - The process needs to be repeated once more with the PIN: - - ``` - > personal.openWallet("keycard://044def09", "PIN number") - ``` - - If everything goes well, you should see your new account when typing `personal` on the console: - - ``` - > personal - WARN [04-09|17:02:07.330] Smartcard wallet account derivation failed url=keycard://044def09 err="Unexpected response status Cla=0x80, Ins=0xd1, Sw=0x6985" - { - listAccounts: [], - listWallets: [{ - status: "Empty, waiting for initialization", - url: "keycard://044def09" - }], - ... - } - ``` - - So the communication with the card is working, but there is no key associated with this wallet. Let's create it: - - ``` - > personal.initializeWallet("keycard://044def09") - "tilt ... impact" - ``` - - You should get a list of words, this is your seed so write them down. Your wallet should now be initialized: - - ``` - > personal.listWallets - [{ - accounts: [{ - address: "0x678b7cd55c61917defb23546a41803c5bfefbc7a", - url: "keycard://044d/m/44'/60'/0'/0/0" - }], - status: "Online", - url: "keycard://044def09" - }] - ``` - - You're all set! - -## Usage - - 1. Start `geth` with the `console` command - 2. Check the card's URL by checking `personal.listWallets`: - -``` - listWallets: [{ - status: "Online, can derive public keys", - url: "keycard://a4d73015" - }] -``` - - 3. Open the wallet, you will be prompted for your pairing password, then PIN: - -``` -personal.openWallet("keycard://a4d73015") -``` - - 4. Check that creation was successful by typing e.g. `personal`. Then use it like a regular wallet. - -## Known issues - - * Starting geth with a valid card seems to make firefox crash. - * PCSC version 4.4 should work, but is currently untested

diff --git go-ethereum/accounts/scwallet/wallet.go celo/accounts/scwallet/wallet.go deleted file mode 100644 index 0caceabdcb01f1f7ba8264e89b00ffe4397d7a9e..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/wallet.go +++ /dev/null @@ -1,1085 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package scwallet - -import ( - "bytes" - "context" - "crypto/hmac" - "crypto/sha256" - "crypto/sha512" - "encoding/asn1" - "encoding/binary" - "errors" - "fmt" - "math/big" - "regexp" - "sort" - "strings" - "sync" - "time" - - "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/log" - pcsc "github.com/gballet/go-libpcsclite" - "github.com/status-im/keycard-go/derivationpath" -) - -// ErrPairingPasswordNeeded is returned if opening the smart card requires pairing with a pairing -// password. In this case, the calling application should request user input to enter -// the pairing password and send it back. -var ErrPairingPasswordNeeded = errors.New("smartcard: pairing password needed") - -// ErrPINNeeded is returned if opening the smart card requires a PIN code. In -// this case, the calling application should request user input to enter the PIN -// and send it back. -var ErrPINNeeded = errors.New("smartcard: pin needed") - -// ErrPINUnblockNeeded is returned if opening the smart card requires a PIN code, -// but all PIN attempts have already been exhausted. In this case the calling -// application should request user input for the PUK and a new PIN code to set -// fo the card. -var ErrPINUnblockNeeded = errors.New("smartcard: pin unblock needed") - -// ErrAlreadyOpen is returned if the smart card is attempted to be opened, but -// there is already a paired and unlocked session. -var ErrAlreadyOpen = errors.New("smartcard: already open") - -// ErrPubkeyMismatch is returned if the public key recovered from a signature -// does not match the one expected by the user. -var ErrPubkeyMismatch = errors.New("smartcard: recovered public key mismatch") - -var ( - appletAID = []byte{0xA0, 0x00, 0x00, 0x08, 0x04, 0x00, 0x01, 0x01, 0x01} - // DerivationSignatureHash is used to derive the public key from the signature of this hash - DerivationSignatureHash = sha256.Sum256(common.Hash{}.Bytes()) -) - -// List of APDU command-related constants -const ( - claISO7816 = 0 - claSCWallet = 0x80 - - insSelect = 0xA4 - insGetResponse = 0xC0 - sw1GetResponse = 0x61 - sw1Ok = 0x90 - - insVerifyPin = 0x20 - insUnblockPin = 0x22 - insExportKey = 0xC2 - insSign = 0xC0 - insLoadKey = 0xD0 - insDeriveKey = 0xD1 - insStatus = 0xF2 -) - -// List of ADPU command parameters -const ( - P1DeriveKeyFromMaster = uint8(0x00) - P1DeriveKeyFromParent = uint8(0x01) - P1DeriveKeyFromCurrent = uint8(0x10) - statusP1WalletStatus = uint8(0x00) - statusP1Path = uint8(0x01) - signP1PrecomputedHash = uint8(0x01) - signP2OnlyBlock = uint8(0x81) - exportP1Any = uint8(0x00) - exportP2Pubkey = uint8(0x01) -) - -// Minimum time to wait between self derivation attempts, even it the user is -// requesting accounts like crazy. -const selfDeriveThrottling = time.Second - -// Wallet represents a smartcard wallet instance. -type Wallet struct { - Hub *Hub // A handle to the Hub that instantiated this wallet. - PublicKey []byte // The wallet's public key (used for communication and identification, not signing!) - - lock sync.Mutex // Lock that gates access to struct fields and communication with the card - card *pcsc.Card // A handle to the smartcard interface for the wallet. - session *Session // The secure communication session with the card - log log.Logger // Contextual logger to tag the base with its id - - deriveNextPaths []accounts.DerivationPath // Next derivation paths for account auto-discovery (multiple bases supported) - deriveNextAddrs []common.Address // Next derived account addresses for auto-discovery (multiple bases supported) - deriveChain ethereum.ChainStateReader // Blockchain state reader to discover used account with - deriveReq chan chan struct{} // Channel to request a self-derivation on - deriveQuit chan chan error // Channel to terminate the self-deriver with -} - -// NewWallet constructs and returns a new Wallet instance. -func NewWallet(hub *Hub, card *pcsc.Card) *Wallet { - wallet := &Wallet{ - Hub: hub, - card: card, - } - return wallet -} - -// transmit sends an APDU to the smartcard and receives and decodes the response. -// It automatically handles requests by the card to fetch the return data separately, -// and returns an error if the response status code is not success. -func transmit(card *pcsc.Card, command *commandAPDU) (*responseAPDU, error) { - data, err := command.serialize() - if err != nil { - return nil, err - } - - responseData, _, err := card.Transmit(data) - if err != nil { - return nil, err - } - - response := new(responseAPDU) - if err = response.deserialize(responseData); err != nil { - return nil, err - } - - // Are we being asked to fetch the response separately? - if response.Sw1 == sw1GetResponse && (command.Cla != claISO7816 || command.Ins != insGetResponse) { - return transmit(card, &commandAPDU{ - Cla: claISO7816, - Ins: insGetResponse, - P1: 0, - P2: 0, - Data: nil, - Le: response.Sw2, - }) - } - - if response.Sw1 != sw1Ok { - return nil, fmt.Errorf("unexpected insecure response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", command.Cla, command.Ins, response.Sw1, response.Sw2) - } - - return response, nil -} - -// applicationInfo encodes information about the smartcard application - its -// instance UID and public key. -type applicationInfo struct { - InstanceUID []byte `asn1:"tag:15"` - PublicKey []byte `asn1:"tag:0"` -} - -// connect connects to the wallet application and establishes a secure channel with it. -// must be called before any other interaction with the wallet. -func (w *Wallet) connect() error { - w.lock.Lock() - defer w.lock.Unlock() - - appinfo, err := w.doselect() - if err != nil { - return err - } - - channel, err := NewSecureChannelSession(w.card, appinfo.PublicKey) - if err != nil { - return err - } - - w.PublicKey = appinfo.PublicKey - w.log = log.New("url", w.URL()) - w.session = &Session{ - Wallet: w, - Channel: channel, - } - return nil -} - -// doselect is an internal (unlocked) function to send a SELECT APDU to the card. -func (w *Wallet) doselect() (*applicationInfo, error) { - response, err := transmit(w.card, &commandAPDU{ - Cla: claISO7816, - Ins: insSelect, - P1: 4, - P2: 0, - Data: appletAID, - }) - if err != nil { - return nil, err - } - - appinfo := new(applicationInfo) - if _, err := asn1.UnmarshalWithParams(response.Data, appinfo, "tag:4"); err != nil { - return nil, err - } - return appinfo, nil -} - -// ping checks the card's status and returns an error if unsuccessful. -func (w *Wallet) ping() error { - w.lock.Lock() - defer w.lock.Unlock() - - // We can't ping if not paired - if !w.session.paired() { - return nil - } - if _, err := w.session.walletStatus(); err != nil { - return err - } - return nil -} - -// release releases any resources held by an open wallet instance. -func (w *Wallet) release() error { - if w.session != nil { - return w.session.release() - } - return nil -} - -// pair is an internal (unlocked) function for establishing a new pairing -// with the wallet. -func (w *Wallet) pair(puk []byte) error { - if w.session.paired() { - return fmt.Errorf("wallet already paired") - } - pairing, err := w.session.pair(puk) - if err != nil { - return err - } - if err = w.Hub.setPairing(w, &pairing); err != nil { - return err - } - return w.session.authenticate(pairing) -} - -// Unpair deletes an existing wallet pairing. -func (w *Wallet) Unpair(pin []byte) error { - w.lock.Lock() - defer w.lock.Unlock() - - if !w.session.paired() { - return fmt.Errorf("wallet %x not paired", w.PublicKey) - } - if err := w.session.verifyPin(pin); err != nil { - return fmt.Errorf("failed to verify pin: %s", err) - } - if err := w.session.unpair(); err != nil { - return fmt.Errorf("failed to unpair: %s", err) - } - if err := w.Hub.setPairing(w, nil); err != nil { - return err - } - return nil -} - -// URL retrieves the canonical path under which this wallet is reachable. It is -// user by upper layers to define a sorting order over all wallets from multiple -// backends. -func (w *Wallet) URL() accounts.URL { - return accounts.URL{ - Scheme: w.Hub.scheme, - Path: fmt.Sprintf("%x", w.PublicKey[1:5]), // Byte #0 isn't unique; 1:5 covers << 64K cards, bump to 1:9 for << 4M - } -} - -// Status returns a textual status to aid the user in the current state of the -// wallet. It also returns an error indicating any failure the wallet might have -// encountered. -func (w *Wallet) Status() (string, error) { - w.lock.Lock() - defer w.lock.Unlock() - - // If the card is not paired, we can only wait - if !w.session.paired() { - return "Unpaired, waiting for pairing password", nil - } - // Yay, we have an encrypted session, retrieve the actual status - status, err := w.session.walletStatus() - if err != nil { - return fmt.Sprintf("Failed: %v", err), err - } - switch { - case !w.session.verified && status.PinRetryCount == 0 && status.PukRetryCount == 0: - return "Bricked, waiting for full wipe", nil - case !w.session.verified && status.PinRetryCount == 0: - return fmt.Sprintf("Blocked, waiting for PUK (%d attempts left) and new PIN", status.PukRetryCount), nil - case !w.session.verified: - return fmt.Sprintf("Locked, waiting for PIN (%d attempts left)", status.PinRetryCount), nil - case !status.Initialized: - return "Empty, waiting for initialization", nil - default: - return "Online", nil - } -} - -// Open initializes access to a wallet instance. It is not meant to unlock or -// decrypt account keys, rather simply to establish a connection to hardware -// wallets and/or to access derivation seeds. -// -// The passphrase parameter may or may not be used by the implementation of a -// particular wallet instance. The reason there is no passwordless open method -// is to strive towards a uniform wallet handling, oblivious to the different -// backend providers. -// -// Please note, if you open a wallet, you must close it to release any allocated -// resources (especially important when working with hardware wallets). -func (w *Wallet) Open(passphrase string) error { - w.lock.Lock() - defer w.lock.Unlock() - - // If the session is already open, bail out - if w.session.verified { - return ErrAlreadyOpen - } - // If the smart card is not yet paired, attempt to do so either from a previous - // pairing key or form the supplied PUK code. - if !w.session.paired() { - // If a previous pairing exists, only ever try to use that - if pairing := w.Hub.pairing(w); pairing != nil { - if err := w.session.authenticate(*pairing); err != nil { - return fmt.Errorf("failed to authenticate card %x: %s", w.PublicKey[:4], err) - } - // Pairing still ok, fall through to PIN checks - } else { - // If no passphrase was supplied, request the PUK from the user - if passphrase == "" { - return ErrPairingPasswordNeeded - } - // Attempt to pair the smart card with the user supplied PUK - if err := w.pair([]byte(passphrase)); err != nil { - return err - } - // Pairing succeeded, fall through to PIN checks. This will of course fail, - // but we can't return ErrPINNeeded directly here because we don't know whether - // a PIN check or a PIN reset is needed. - passphrase = "" - } - } - // The smart card was successfully paired, retrieve its status to check whether - // PIN verification or unblocking is needed. - status, err := w.session.walletStatus() - if err != nil { - return err - } - // Request the appropriate next authentication data, or use the one supplied - switch { - case passphrase == "" && status.PinRetryCount > 0: - return ErrPINNeeded - case passphrase == "": - return ErrPINUnblockNeeded - case status.PinRetryCount > 0: - if !regexp.MustCompile(`^[0-9]{6,}$`).MatchString(passphrase) { - w.log.Error("PIN needs to be at least 6 digits") - return ErrPINNeeded - } - if err := w.session.verifyPin([]byte(passphrase)); err != nil { - return err - } - default: - if !regexp.MustCompile(`^[0-9]{12,}$`).MatchString(passphrase) { - w.log.Error("PUK needs to be at least 12 digits") - return ErrPINUnblockNeeded - } - if err := w.session.unblockPin([]byte(passphrase)); err != nil { - return err - } - } - // Smart card paired and unlocked, initialize and register - w.deriveReq = make(chan chan struct{}) - w.deriveQuit = make(chan chan error) - - go w.selfDerive() - - // Notify anyone listening for wallet events that a new device is accessible - go w.Hub.updateFeed.Send(accounts.WalletEvent{Wallet: w, Kind: accounts.WalletOpened}) - - return nil -} - -// Close stops and closes the wallet, freeing any resources. -func (w *Wallet) Close() error { - // Ensure the wallet was opened - w.lock.Lock() - dQuit := w.deriveQuit - w.lock.Unlock() - - // Terminate the self-derivations - var derr error - if dQuit != nil { - errc := make(chan error) - dQuit <- errc - derr = <-errc // Save for later, we *must* close the USB - } - // Terminate the device connection - w.lock.Lock() - defer w.lock.Unlock() - - w.deriveQuit = nil - w.deriveReq = nil - - if err := w.release(); err != nil { - return err - } - return derr -} - -// selfDerive is an account derivation loop that upon request attempts to find -// new non-zero accounts. -func (w *Wallet) selfDerive() { - w.log.Debug("Smart card wallet self-derivation started") - defer w.log.Debug("Smart card wallet self-derivation stopped") - - // Execute self-derivations until termination or error - var ( - reqc chan struct{} - errc chan error - err error - ) - for errc == nil && err == nil { - // Wait until either derivation or termination is requested - select { - case errc = <-w.deriveQuit: - // Termination requested - continue - case reqc = <-w.deriveReq: - // Account discovery requested - } - // Derivation needs a chain and device access, skip if either unavailable - w.lock.Lock() - if w.session == nil || w.deriveChain == nil { - w.lock.Unlock() - reqc <- struct{}{} - continue - } - pairing := w.Hub.pairing(w) - - // Device lock obtained, derive the next batch of accounts - var ( - paths []accounts.DerivationPath - nextAcc accounts.Account - - nextPaths = append([]accounts.DerivationPath{}, w.deriveNextPaths...) - nextAddrs = append([]common.Address{}, w.deriveNextAddrs...) - - context = context.Background() - ) - for i := 0; i < len(nextAddrs); i++ { - for empty := false; !empty; { - // Retrieve the next derived Ethereum account - if nextAddrs[i] == (common.Address{}) { - if nextAcc, err = w.session.derive(nextPaths[i]); err != nil { - w.log.Warn("Smartcard wallet account derivation failed", "err", err) - break - } - nextAddrs[i] = nextAcc.Address - } - // Check the account's status against the current chain state - var ( - balance *big.Int - nonce uint64 - ) - balance, err = w.deriveChain.BalanceAt(context, nextAddrs[i], nil) - if err != nil { - w.log.Warn("Smartcard wallet balance retrieval failed", "err", err) - break - } - nonce, err = w.deriveChain.NonceAt(context, nextAddrs[i], nil) - if err != nil { - w.log.Warn("Smartcard wallet nonce retrieval failed", "err", err) - break - } - // If the next account is empty, stop self-derivation, but add for the last base path - if balance.Sign() == 0 && nonce == 0 { - empty = true - if i < len(nextAddrs)-1 { - break - } - } - // We've just self-derived a new account, start tracking it locally - path := make(accounts.DerivationPath, len(nextPaths[i])) - copy(path[:], nextPaths[i][:]) - paths = append(paths, path) - - // Display a log message to the user for new (or previously empty accounts) - if _, known := pairing.Accounts[nextAddrs[i]]; !known || !empty || nextAddrs[i] != w.deriveNextAddrs[i] { - w.log.Info("Smartcard wallet discovered new account", "address", nextAddrs[i], "path", path, "balance", balance, "nonce", nonce) - } - pairing.Accounts[nextAddrs[i]] = path - - // Fetch the next potential account - if !empty { - nextAddrs[i] = common.Address{} - nextPaths[i][len(nextPaths[i])-1]++ - } - } - } - // If there are new accounts, write them out - if len(paths) > 0 { - err = w.Hub.setPairing(w, pairing) - } - // Shift the self-derivation forward - w.deriveNextAddrs = nextAddrs - w.deriveNextPaths = nextPaths - - // Self derivation complete, release device lock - w.lock.Unlock() - - // Notify the user of termination and loop after a bit of time (to avoid trashing) - reqc <- struct{}{} - if err == nil { - select { - case errc = <-w.deriveQuit: - // Termination requested, abort - case <-time.After(selfDeriveThrottling): - // Waited enough, willing to self-derive again - } - } - } - // In case of error, wait for termination - if err != nil { - w.log.Debug("Smartcard wallet self-derivation failed", "err", err) - errc = <-w.deriveQuit - } - errc <- err -} - -// Accounts retrieves the list of signing accounts the wallet is currently aware -// of. For hierarchical deterministic wallets, the list will not be exhaustive, -// rather only contain the accounts explicitly pinned during account derivation. -func (w *Wallet) Accounts() []accounts.Account { - // Attempt self-derivation if it's running - reqc := make(chan struct{}, 1) - select { - case w.deriveReq <- reqc: - // Self-derivation request accepted, wait for it - <-reqc - default: - // Self-derivation offline, throttled or busy, skip - } - - w.lock.Lock() - defer w.lock.Unlock() - - if pairing := w.Hub.pairing(w); pairing != nil { - ret := make([]accounts.Account, 0, len(pairing.Accounts)) - for address, path := range pairing.Accounts { - ret = append(ret, w.makeAccount(address, path)) - } - sort.Sort(accounts.AccountsByURL(ret)) - return ret - } - return nil -} - -func (w *Wallet) makeAccount(address common.Address, path accounts.DerivationPath) accounts.Account { - return accounts.Account{ - Address: address, - URL: accounts.URL{ - Scheme: w.Hub.scheme, - Path: fmt.Sprintf("%x/%s", w.PublicKey[1:3], path.String()), - }, - } -} - -// Contains returns whether an account is part of this particular wallet or not. -func (w *Wallet) Contains(account accounts.Account) bool { - if pairing := w.Hub.pairing(w); pairing != nil { - _, ok := pairing.Accounts[account.Address] - return ok - } - return false -} - -// Initialize installs a keypair generated from the provided key into the wallet. -func (w *Wallet) Initialize(seed []byte) error { - go w.selfDerive() - // DO NOT lock at this stage, as the initialize - // function relies on Status() - return w.session.initialize(seed) -} - -// Derive attempts to explicitly derive a hierarchical deterministic account at -// the specified derivation path. If requested, the derived account will be added -// to the wallet's tracked account list. -func (w *Wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) { - w.lock.Lock() - defer w.lock.Unlock() - - account, err := w.session.derive(path) - if err != nil { - return accounts.Account{}, err - } - - if pin { - pairing := w.Hub.pairing(w) - pairing.Accounts[account.Address] = path - if err := w.Hub.setPairing(w, pairing); err != nil { - return accounts.Account{}, err - } - } - - return account, nil -} - -// SelfDerive sets a base account derivation path from which the wallet attempts -// to discover non zero accounts and automatically add them to list of tracked -// accounts. -// -// Note, self derivation will increment the last component of the specified path -// opposed to decending into a child path to allow discovering accounts starting -// from non zero components. -// -// Some hardware wallets switched derivation paths through their evolution, so -// this method supports providing multiple bases to discover old user accounts -// too. Only the last base will be used to derive the next empty account. -// -// You can disable automatic account discovery by calling SelfDerive with a nil -// chain state reader. -func (w *Wallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) { - w.lock.Lock() - defer w.lock.Unlock() - - w.deriveNextPaths = make([]accounts.DerivationPath, len(bases)) - for i, base := range bases { - w.deriveNextPaths[i] = make(accounts.DerivationPath, len(base)) - copy(w.deriveNextPaths[i][:], base[:]) - } - w.deriveNextAddrs = make([]common.Address, len(bases)) - w.deriveChain = chain -} - -// SignData requests the wallet to sign the hash of the given data. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -// -// If the wallet requires additional authentication to sign the request (e.g. -// a password to decrypt the account, or a PIN code o verify the transaction), -// an AuthNeededError instance will be returned, containing infos for the user -// about which fields or actions are needed. The user may retry by providing -// the needed details via SignDataWithPassphrase, or by other means (e.g. unlock -// the account in a keystore). -func (w *Wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) { - return w.signHash(account, crypto.Keccak256(data)) -} - -func (w *Wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) { - w.lock.Lock() - defer w.lock.Unlock() - - path, err := w.findAccountPath(account) - if err != nil { - return nil, err - } - - return w.session.sign(path, hash) -} - -// SignTx requests the wallet to sign the given transaction. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -// -// If the wallet requires additional authentication to sign the request (e.g. -// a password to decrypt the account, or a PIN code o verify the transaction), -// an AuthNeededError instance will be returned, containing infos for the user -// about which fields or actions are needed. The user may retry by providing -// the needed details via SignTxWithPassphrase, or by other means (e.g. unlock -// the account in a keystore). -func (w *Wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { - signer := types.LatestSignerForChainID(chainID) - hash := signer.Hash(tx) - sig, err := w.signHash(account, hash[:]) - if err != nil { - return nil, err - } - return tx.WithSignature(signer, sig) -} - -// SignDataWithPassphrase requests the wallet to sign the given hash with the -// given passphrase as extra authentication information. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -func (w *Wallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) { - return w.signHashWithPassphrase(account, passphrase, crypto.Keccak256(data)) -} - -func (w *Wallet) signHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) { - if !w.session.verified { - if err := w.Open(passphrase); err != nil { - return nil, err - } - } - - return w.signHash(account, hash) -} - -// SignText requests the wallet to sign the hash of a given piece of data, prefixed -// by the Ethereum prefix scheme -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -// -// If the wallet requires additional authentication to sign the request (e.g. -// a password to decrypt the account, or a PIN code o verify the transaction), -// an AuthNeededError instance will be returned, containing infos for the user -// about which fields or actions are needed. The user may retry by providing -// the needed details via SignHashWithPassphrase, or by other means (e.g. unlock -// the account in a keystore). -func (w *Wallet) SignText(account accounts.Account, text []byte) ([]byte, error) { - return w.signHash(account, accounts.TextHash(text)) -} - -// SignTextWithPassphrase implements accounts.Wallet, attempting to sign the -// given hash with the given account using passphrase as extra authentication -func (w *Wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) { - return w.signHashWithPassphrase(account, passphrase, crypto.Keccak256(accounts.TextHash(text))) -} - -// SignTxWithPassphrase requests the wallet to sign the given transaction, with the -// given passphrase as extra authentication information. -// -// It looks up the account specified either solely via its address contained within, -// or optionally with the aid of any location metadata from the embedded URL field. -func (w *Wallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) { - if !w.session.verified { - if err := w.Open(passphrase); err != nil { - return nil, err - } - } - return w.SignTx(account, tx, chainID) -} - -// findAccountPath returns the derivation path for the provided account. -// It first checks for the address in the list of pinned accounts, and if it is -// not found, attempts to parse the derivation path from the account's URL. -func (w *Wallet) findAccountPath(account accounts.Account) (accounts.DerivationPath, error) { - pairing := w.Hub.pairing(w) - if path, ok := pairing.Accounts[account.Address]; ok { - return path, nil - } - - // Look for the path in the URL - if account.URL.Scheme != w.Hub.scheme { - return nil, fmt.Errorf("scheme %s does not match wallet scheme %s", account.URL.Scheme, w.Hub.scheme) - } - - parts := strings.SplitN(account.URL.Path, "/", 2) - if len(parts) != 2 { - return nil, fmt.Errorf("invalid URL format: %s", account.URL) - } - - if parts[0] != fmt.Sprintf("%x", w.PublicKey[1:3]) { - return nil, fmt.Errorf("URL %s is not for this wallet", account.URL) - } - - return accounts.ParseDerivationPath(parts[1]) -} - -// Session represents a secured communication session with the wallet. -type Session struct { - Wallet *Wallet // A handle to the wallet that opened the session - Channel *SecureChannelSession // A secure channel for encrypted messages - verified bool // Whether the pin has been verified in this session. -} - -// pair establishes a new pairing over this channel, using the provided secret. -func (s *Session) pair(secret []byte) (smartcardPairing, error) { - err := s.Channel.Pair(secret) - if err != nil { - return smartcardPairing{}, err - } - - return smartcardPairing{ - PublicKey: s.Wallet.PublicKey, - PairingIndex: s.Channel.PairingIndex, - PairingKey: s.Channel.PairingKey, - Accounts: make(map[common.Address]accounts.DerivationPath), - }, nil -} - -// unpair deletes an existing pairing. -func (s *Session) unpair() error { - if !s.verified { - return fmt.Errorf("unpair requires that the PIN be verified") - } - return s.Channel.Unpair() -} - -// verifyPin unlocks a wallet with the provided pin. -func (s *Session) verifyPin(pin []byte) error { - if _, err := s.Channel.transmitEncrypted(claSCWallet, insVerifyPin, 0, 0, pin); err != nil { - return err - } - s.verified = true - return nil -} - -// unblockPin unblocks a wallet with the provided puk and resets the pin to the -// new one specified. -func (s *Session) unblockPin(pukpin []byte) error { - if _, err := s.Channel.transmitEncrypted(claSCWallet, insUnblockPin, 0, 0, pukpin); err != nil { - return err - } - s.verified = true - return nil -} - -// release releases resources associated with the channel. -func (s *Session) release() error { - return s.Wallet.card.Disconnect(pcsc.LeaveCard) -} - -// paired returns true if a valid pairing exists. -func (s *Session) paired() bool { - return s.Channel.PairingKey != nil -} - -// authenticate uses an existing pairing to establish a secure channel. -func (s *Session) authenticate(pairing smartcardPairing) error { - if !bytes.Equal(s.Wallet.PublicKey, pairing.PublicKey) { - return fmt.Errorf("cannot pair using another wallet's pairing; %x != %x", s.Wallet.PublicKey, pairing.PublicKey) - } - s.Channel.PairingKey = pairing.PairingKey - s.Channel.PairingIndex = pairing.PairingIndex - return s.Channel.Open() -} - -// walletStatus describes a smartcard wallet's status information. -type walletStatus struct { - PinRetryCount int // Number of remaining PIN retries - PukRetryCount int // Number of remaining PUK retries - Initialized bool // Whether the card has been initialized with a private key -} - -// walletStatus fetches the wallet's status from the card. -func (s *Session) walletStatus() (*walletStatus, error) { - response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1WalletStatus, 0, nil) - if err != nil { - return nil, err - } - - status := new(walletStatus) - if _, err := asn1.UnmarshalWithParams(response.Data, status, "tag:3"); err != nil { - return nil, err - } - return status, nil -} - -// derivationPath fetches the wallet's current derivation path from the card. -//lint:ignore U1000 needs to be added to the console interface -func (s *Session) derivationPath() (accounts.DerivationPath, error) { - response, err := s.Channel.transmitEncrypted(claSCWallet, insStatus, statusP1Path, 0, nil) - if err != nil { - return nil, err - } - buf := bytes.NewReader(response.Data) - path := make(accounts.DerivationPath, len(response.Data)/4) - return path, binary.Read(buf, binary.BigEndian, &path) -} - -// initializeData contains data needed to initialize the smartcard wallet. -type initializeData struct { - PublicKey []byte `asn1:"tag:0"` - PrivateKey []byte `asn1:"tag:1"` - ChainCode []byte `asn1:"tag:2"` -} - -// initialize initializes the card with new key data. -func (s *Session) initialize(seed []byte) error { - // Check that the wallet isn't currently initialized, - // otherwise the key would be overwritten. - status, err := s.Wallet.Status() - if err != nil { - return err - } - if status == "Online" { - return fmt.Errorf("card is already initialized, cowardly refusing to proceed") - } - - s.Wallet.lock.Lock() - defer s.Wallet.lock.Unlock() - - // HMAC the seed to produce the private key and chain code - mac := hmac.New(sha512.New, []byte("Bitcoin seed")) - mac.Write(seed) - seed = mac.Sum(nil) - - key, err := crypto.ToECDSA(seed[:32]) - if err != nil { - return err - } - - id := initializeData{} - id.PublicKey = crypto.FromECDSAPub(&key.PublicKey) - id.PrivateKey = seed[:32] - id.ChainCode = seed[32:] - data, err := asn1.Marshal(id) - if err != nil { - return err - } - - // Nasty hack to force the top-level struct tag to be context-specific - data[0] = 0xA1 - - _, err = s.Channel.transmitEncrypted(claSCWallet, insLoadKey, 0x02, 0, data) - return err -} - -// derive derives a new HD key path on the card. -func (s *Session) derive(path accounts.DerivationPath) (accounts.Account, error) { - startingPoint, path, err := derivationpath.Decode(path.String()) - if err != nil { - return accounts.Account{}, err - } - - var p1 uint8 - switch startingPoint { - case derivationpath.StartingPointMaster: - p1 = P1DeriveKeyFromMaster - case derivationpath.StartingPointParent: - p1 = P1DeriveKeyFromParent - case derivationpath.StartingPointCurrent: - p1 = P1DeriveKeyFromCurrent - default: - return accounts.Account{}, fmt.Errorf("invalid startingPoint %d", startingPoint) - } - - data := new(bytes.Buffer) - for _, segment := range path { - if err := binary.Write(data, binary.BigEndian, segment); err != nil { - return accounts.Account{}, err - } - } - - _, err = s.Channel.transmitEncrypted(claSCWallet, insDeriveKey, p1, 0, data.Bytes()) - if err != nil { - return accounts.Account{}, err - } - - response, err := s.Channel.transmitEncrypted(claSCWallet, insSign, 0, 0, DerivationSignatureHash[:]) - if err != nil { - return accounts.Account{}, err - } - - sigdata := new(signatureData) - if _, err := asn1.UnmarshalWithParams(response.Data, sigdata, "tag:0"); err != nil { - return accounts.Account{}, err - } - rbytes, sbytes := sigdata.Signature.R.Bytes(), sigdata.Signature.S.Bytes() - sig := make([]byte, 65) - copy(sig[32-len(rbytes):32], rbytes) - copy(sig[64-len(sbytes):64], sbytes) - - if err := confirmPublicKey(sig, sigdata.PublicKey); err != nil { - return accounts.Account{}, err - } - pub, err := crypto.UnmarshalPubkey(sigdata.PublicKey) - if err != nil { - return accounts.Account{}, err - } - return s.Wallet.makeAccount(crypto.PubkeyToAddress(*pub), path), nil -} - -// keyExport contains information on an exported keypair. -//lint:ignore U1000 needs to be added to the console interface -type keyExport struct { - PublicKey []byte `asn1:"tag:0"` - PrivateKey []byte `asn1:"tag:1,optional"` -} - -// publicKey returns the public key for the current derivation path. -//lint:ignore U1000 needs to be added to the console interface -func (s *Session) publicKey() ([]byte, error) { - response, err := s.Channel.transmitEncrypted(claSCWallet, insExportKey, exportP1Any, exportP2Pubkey, nil) - if err != nil { - return nil, err - } - keys := new(keyExport) - if _, err := asn1.UnmarshalWithParams(response.Data, keys, "tag:1"); err != nil { - return nil, err - } - return keys.PublicKey, nil -} - -// signatureData contains information on a signature - the signature itself and -// the corresponding public key. -type signatureData struct { - PublicKey []byte `asn1:"tag:0"` - Signature struct { - R *big.Int - S *big.Int - } -} - -// sign asks the card to sign a message, and returns a valid signature after -// recovering the v value. -func (s *Session) sign(path accounts.DerivationPath, hash []byte) ([]byte, error) { - startTime := time.Now() - _, err := s.derive(path) - if err != nil { - return nil, err - } - deriveTime := time.Now() - - response, err := s.Channel.transmitEncrypted(claSCWallet, insSign, signP1PrecomputedHash, signP2OnlyBlock, hash) - if err != nil { - return nil, err - } - sigdata := new(signatureData) - if _, err := asn1.UnmarshalWithParams(response.Data, sigdata, "tag:0"); err != nil { - return nil, err - } - // Serialize the signature - rbytes, sbytes := sigdata.Signature.R.Bytes(), sigdata.Signature.S.Bytes() - sig := make([]byte, 65) - copy(sig[32-len(rbytes):32], rbytes) - copy(sig[64-len(sbytes):64], sbytes) - - // Recover the V value. - sig, err = makeRecoverableSignature(hash, sig, sigdata.PublicKey) - if err != nil { - return nil, err - } - log.Debug("Signed using smartcard", "deriveTime", deriveTime.Sub(startTime), "signingTime", time.Since(deriveTime)) - - return sig, nil -} - -// confirmPublicKey confirms that the given signature belongs to the specified key. -func confirmPublicKey(sig, pubkey []byte) error { - _, err := makeRecoverableSignature(DerivationSignatureHash[:], sig, pubkey) - return err -} - -// makeRecoverableSignature uses a signature and an expected public key to -// recover the v value and produce a recoverable signature. -func makeRecoverableSignature(hash, sig, expectedPubkey []byte) ([]byte, error) { - var libraryError error - for v := 0; v < 2; v++ { - sig[64] = byte(v) - if pubkey, err := crypto.Ecrecover(hash, sig); err == nil { - if bytes.Equal(pubkey, expectedPubkey) { - return sig, nil - } - } else { - libraryError = err - } - } - if libraryError != nil { - return nil, libraryError - } - return nil, ErrPubkeyMismatch -}

diff --git go-ethereum/accounts/scwallet/hub.go celo/accounts/scwallet/hub.go deleted file mode 100644 index fc4f3c5eb7c065a04e414ba150e362214b0a37bf..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/hub.go +++ /dev/null @@ -1,302 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -// This package implements support for smartcard-based hardware wallets such as -// the one written by Status: https://github.com/status-im/hardware-wallet -// -// This implementation of smartcard wallets have a different interaction process -// to other types of hardware wallet. The process works like this: -// -// 1. (First use with a given client) Establish a pairing between hardware -// wallet and client. This requires a secret value called a 'pairing password'. -// You can pair with an unpaired wallet with `personal.openWallet(URI, pairing password)`. -// 2. (First use only) Initialize the wallet, which generates a keypair, stores -// it on the wallet, and returns it so the user can back it up. You can -// initialize a wallet with `personal.initializeWallet(URI)`. -// 3. Connect to the wallet using the pairing information established in step 1. -// You can connect to a paired wallet with `personal.openWallet(URI, PIN)`. -// 4. Interact with the wallet as normal. - -package scwallet - -import ( - "encoding/json" - "io/ioutil" - "os" - "path/filepath" - "sort" - "sync" - "time" - - "github.com/ethereum/go-ethereum/accounts" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/event" - "github.com/ethereum/go-ethereum/log" - pcsc "github.com/gballet/go-libpcsclite" -) - -// Scheme is the URI prefix for smartcard wallets. -const Scheme = "keycard" - -// refreshCycle is the maximum time between wallet refreshes (if USB hotplug -// notifications don't work). -const refreshCycle = time.Second - -// refreshThrottling is the minimum time between wallet refreshes to avoid thrashing. -const refreshThrottling = 500 * time.Millisecond - -// smartcardPairing contains information about a smart card we have paired with -// or might pair with the hub. -type smartcardPairing struct { - PublicKey []byte `json:"publicKey"` - PairingIndex uint8 `json:"pairingIndex"` - PairingKey []byte `json:"pairingKey"` - Accounts map[common.Address]accounts.DerivationPath `json:"accounts"` -} - -// Hub is a accounts.Backend that can find and handle generic PC/SC hardware wallets. -type Hub struct { - scheme string // Protocol scheme prefixing account and wallet URLs. - - context *pcsc.Client - datadir string - pairings map[string]smartcardPairing - - refreshed time.Time // Time instance when the list of wallets was last refreshed - wallets map[string]*Wallet // Mapping from reader names to wallet instances - updateFeed event.Feed // Event feed to notify wallet additions/removals - updateScope event.SubscriptionScope // Subscription scope tracking current live listeners - updating bool // Whether the event notification loop is running - - quit chan chan error - - stateLock sync.RWMutex // Protects the internals of the hub from racey access -} - -func (hub *Hub) readPairings() error { - hub.pairings = make(map[string]smartcardPairing) - pairingFile, err := os.Open(filepath.Join(hub.datadir, "smartcards.json")) - if err != nil { - if os.IsNotExist(err) { - return nil - } - return err - } - - pairingData, err := ioutil.ReadAll(pairingFile) - if err != nil { - return err - } - var pairings []smartcardPairing - if err := json.Unmarshal(pairingData, &pairings); err != nil { - return err - } - - for _, pairing := range pairings { - hub.pairings[string(pairing.PublicKey)] = pairing - } - return nil -} - -func (hub *Hub) writePairings() error { - pairingFile, err := os.OpenFile(filepath.Join(hub.datadir, "smartcards.json"), os.O_RDWR|os.O_CREATE, 0755) - if err != nil { - return err - } - defer pairingFile.Close() - - pairings := make([]smartcardPairing, 0, len(hub.pairings)) - for _, pairing := range hub.pairings { - pairings = append(pairings, pairing) - } - - pairingData, err := json.Marshal(pairings) - if err != nil { - return err - } - - if _, err := pairingFile.Write(pairingData); err != nil { - return err - } - - return nil -} - -func (hub *Hub) pairing(wallet *Wallet) *smartcardPairing { - if pairing, ok := hub.pairings[string(wallet.PublicKey)]; ok { - return &pairing - } - return nil -} - -func (hub *Hub) setPairing(wallet *Wallet, pairing *smartcardPairing) error { - if pairing == nil { - delete(hub.pairings, string(wallet.PublicKey)) - } else { - hub.pairings[string(wallet.PublicKey)] = *pairing - } - return hub.writePairings() -} - -// NewHub creates a new hardware wallet manager for smartcards. -func NewHub(daemonPath string, scheme string, datadir string) (*Hub, error) { - context, err := pcsc.EstablishContext(daemonPath, pcsc.ScopeSystem) - if err != nil { - return nil, err - } - hub := &Hub{ - scheme: scheme, - context: context, - datadir: datadir, - wallets: make(map[string]*Wallet), - quit: make(chan chan error), - } - if err := hub.readPairings(); err != nil { - return nil, err - } - hub.refreshWallets() - return hub, nil -} - -// Wallets implements accounts.Backend, returning all the currently tracked smart -// cards that appear to be hardware wallets. -func (hub *Hub) Wallets() []accounts.Wallet { - // Make sure the list of wallets is up to date - hub.refreshWallets() - - hub.stateLock.RLock() - defer hub.stateLock.RUnlock() - - cpy := make([]accounts.Wallet, 0, len(hub.wallets)) - for _, wallet := range hub.wallets { - cpy = append(cpy, wallet) - } - sort.Sort(accounts.WalletsByURL(cpy)) - return cpy -} - -// refreshWallets scans the devices attached to the machine and updates the -// list of wallets based on the found devices. -func (hub *Hub) refreshWallets() { - // Don't scan the USB like crazy it the user fetches wallets in a loop - hub.stateLock.RLock() - elapsed := time.Since(hub.refreshed) - hub.stateLock.RUnlock() - - if elapsed < refreshThrottling { - return - } - // Retrieve all the smart card reader to check for cards - readers, err := hub.context.ListReaders() - if err != nil { - // This is a perverted hack, the scard library returns an error if no card - // readers are present instead of simply returning an empty list. We don't - // want to fill the user's log with errors, so filter those out. - if err.Error() != "scard: Cannot find a smart card reader." { - log.Error("Failed to enumerate smart card readers", "err", err) - return - } - } - // Transform the current list of wallets into the new one - hub.stateLock.Lock() - - events := []accounts.WalletEvent{} - seen := make(map[string]struct{}) - - for _, reader := range readers { - // Mark the reader as present - seen[reader] = struct{}{} - - // If we already know about this card, skip to the next reader, otherwise clean up - if wallet, ok := hub.wallets[reader]; ok { - if err := wallet.ping(); err == nil { - continue - } - wallet.Close() - events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped}) - delete(hub.wallets, reader) - } - // New card detected, try to connect to it - card, err := hub.context.Connect(reader, pcsc.ShareShared, pcsc.ProtocolAny) - if err != nil { - log.Debug("Failed to open smart card", "reader", reader, "err", err) - continue - } - wallet := NewWallet(hub, card) - if err = wallet.connect(); err != nil { - log.Debug("Failed to connect to smart card", "reader", reader, "err", err) - card.Disconnect(pcsc.LeaveCard) - continue - } - // Card connected, start tracking in amongs the wallets - hub.wallets[reader] = wallet - events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived}) - } - // Remove any wallets no longer present - for reader, wallet := range hub.wallets { - if _, ok := seen[reader]; !ok { - wallet.Close() - events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped}) - delete(hub.wallets, reader) - } - } - hub.refreshed = time.Now() - hub.stateLock.Unlock() - - for _, event := range events { - hub.updateFeed.Send(event) - } -} - -// Subscribe implements accounts.Backend, creating an async subscription to -// receive notifications on the addition or removal of smart card wallets. -func (hub *Hub) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription { - // We need the mutex to reliably start/stop the update loop - hub.stateLock.Lock() - defer hub.stateLock.Unlock() - - // Subscribe the caller and track the subscriber count - sub := hub.updateScope.Track(hub.updateFeed.Subscribe(sink)) - - // Subscribers require an active notification loop, start it - if !hub.updating { - hub.updating = true - go hub.updater() - } - return sub -} - -// updater is responsible for maintaining an up-to-date list of wallets managed -// by the smart card hub, and for firing wallet addition/removal events. -func (hub *Hub) updater() { - for { - // TODO: Wait for a USB hotplug event (not supported yet) or a refresh timeout - // <-hub.changes - time.Sleep(refreshCycle) - - // Run the wallet refresher - hub.refreshWallets() - - // If all our subscribers left, stop the updater - hub.stateLock.Lock() - if hub.updateScope.Count() == 0 { - hub.updating = false - hub.stateLock.Unlock() - return - } - hub.stateLock.Unlock() - } -}

diff --git go-ethereum/accounts/scwallet/securechannel.go celo/accounts/scwallet/securechannel.go deleted file mode 100644 index b3ae6a73d472950bebfd4d6aa2ae89b84ec33c73..0000000000000000000000000000000000000000 --- go-ethereum/accounts/scwallet/securechannel.go +++ /dev/null @@ -1,339 +0,0 @@ -// Copyright 2018 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package scwallet - -import ( - "bytes" - "crypto/aes" - "crypto/cipher" - "crypto/elliptic" - "crypto/rand" - "crypto/sha256" - "crypto/sha512" - "fmt" - - "github.com/ethereum/go-ethereum/crypto" - pcsc "github.com/gballet/go-libpcsclite" - "golang.org/x/crypto/pbkdf2" - "golang.org/x/text/unicode/norm" -) - -const ( - maxPayloadSize = 223 - pairP1FirstStep = 0 - pairP1LastStep = 1 - - scSecretLength = 32 - scBlockSize = 16 - - insOpenSecureChannel = 0x10 - insMutuallyAuthenticate = 0x11 - insPair = 0x12 - insUnpair = 0x13 - - pairingSalt = "Keycard Pairing Password Salt" -) - -// SecureChannelSession enables secure communication with a hardware wallet. -type SecureChannelSession struct { - card *pcsc.Card // A handle to the smartcard for communication - secret []byte // A shared secret generated from our ECDSA keys - publicKey []byte // Our own ephemeral public key - PairingKey []byte // A permanent shared secret for a pairing, if present - sessionEncKey []byte // The current session encryption key - sessionMacKey []byte // The current session MAC key - iv []byte // The current IV - PairingIndex uint8 // The pairing index -} - -// NewSecureChannelSession creates a new secure channel for the given card and public key. -func NewSecureChannelSession(card *pcsc.Card, keyData []byte) (*SecureChannelSession, error) { - // Generate an ECDSA keypair for ourselves - key, err := crypto.GenerateKey() - if err != nil { - return nil, err - } - cardPublic, err := crypto.UnmarshalPubkey(keyData) - if err != nil { - return nil, fmt.Errorf("could not unmarshal public key from card: %v", err) - } - secret, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes()) - return &SecureChannelSession{ - card: card, - secret: secret.Bytes(), - publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y), - }, nil -} - -// Pair establishes a new pairing with the smartcard. -func (s *SecureChannelSession) Pair(pairingPassword []byte) error { - secretHash := pbkdf2.Key(norm.NFKD.Bytes(pairingPassword), norm.NFKD.Bytes([]byte(pairingSalt)), 50000, 32, sha256.New) - - challenge := make([]byte, 32) - if _, err := rand.Read(challenge); err != nil { - return err - } - - response, err := s.pair(pairP1FirstStep, challenge) - if err != nil { - return err - } - - md := sha256.New() - md.Write(secretHash[:]) - md.Write(challenge) - - expectedCryptogram := md.Sum(nil) - cardCryptogram := response.Data[:32] - cardChallenge := response.Data[32:64] - - if !bytes.Equal(expectedCryptogram, cardCryptogram) { - return fmt.Errorf("invalid card cryptogram %v != %v", expectedCryptogram, cardCryptogram) - } - - md.Reset() - md.Write(secretHash[:]) - md.Write(cardChallenge) - response, err = s.pair(pairP1LastStep, md.Sum(nil)) - if err != nil { - return err - } - - md.Reset() - md.Write(secretHash[:]) - md.Write(response.Data[1:]) - s.PairingKey = md.Sum(nil) - s.PairingIndex = response.Data[0] - - return nil -} - -// Unpair disestablishes an existing pairing. -func (s *SecureChannelSession) Unpair() error { - if s.PairingKey == nil { - return fmt.Errorf("cannot unpair: not paired") - } - - _, err := s.transmitEncrypted(claSCWallet, insUnpair, s.PairingIndex, 0, []byte{}) - if err != nil { - return err - } - s.PairingKey = nil - // Close channel - s.iv = nil - return nil -} - -// Open initializes the secure channel. -func (s *SecureChannelSession) Open() error { - if s.iv != nil { - return fmt.Errorf("session already opened") - } - - response, err := s.open() - if err != nil { - return err - } - - // Generate the encryption/mac key by hashing our shared secret, - // pairing key, and the first bytes returned from the Open APDU. - md := sha512.New() - md.Write(s.secret) - md.Write(s.PairingKey) - md.Write(response.Data[:scSecretLength]) - keyData := md.Sum(nil) - s.sessionEncKey = keyData[:scSecretLength] - s.sessionMacKey = keyData[scSecretLength : scSecretLength*2] - - // The IV is the last bytes returned from the Open APDU. - s.iv = response.Data[scSecretLength:] - - return s.mutuallyAuthenticate() -} - -// mutuallyAuthenticate is an internal method to authenticate both ends of the -// connection. -func (s *SecureChannelSession) mutuallyAuthenticate() error { - data := make([]byte, scSecretLength) - if _, err := rand.Read(data); err != nil { - return err - } - - response, err := s.transmitEncrypted(claSCWallet, insMutuallyAuthenticate, 0, 0, data) - if err != nil { - return err - } - if response.Sw1 != 0x90 || response.Sw2 != 0x00 { - return fmt.Errorf("got unexpected response from MUTUALLY_AUTHENTICATE: 0x%x%x", response.Sw1, response.Sw2) - } - - if len(response.Data) != scSecretLength { - return fmt.Errorf("response from MUTUALLY_AUTHENTICATE was %d bytes, expected %d", len(response.Data), scSecretLength) - } - - return nil -} - -// open is an internal method that sends an open APDU. -func (s *SecureChannelSession) open() (*responseAPDU, error) { - return transmit(s.card, &commandAPDU{ - Cla: claSCWallet, - Ins: insOpenSecureChannel, - P1: s.PairingIndex, - P2: 0, - Data: s.publicKey, - Le: 0, - }) -} - -// pair is an internal method that sends a pair APDU. -func (s *SecureChannelSession) pair(p1 uint8, data []byte) (*responseAPDU, error) { - return transmit(s.card, &commandAPDU{ - Cla: claSCWallet, - Ins: insPair, - P1: p1, - P2: 0, - Data: data, - Le: 0, - }) -} - -// transmitEncrypted sends an encrypted message, and decrypts and returns the response. -func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []byte) (*responseAPDU, error) { - if s.iv == nil { - return nil, fmt.Errorf("channel not open") - } - - data, err := s.encryptAPDU(data) - if err != nil { - return nil, err - } - meta := [16]byte{cla, ins, p1, p2, byte(len(data) + scBlockSize)} - if err = s.updateIV(meta[:], data); err != nil { - return nil, err - } - - fulldata := make([]byte, len(s.iv)+len(data)) - copy(fulldata, s.iv) - copy(fulldata[len(s.iv):], data) - - response, err := transmit(s.card, &commandAPDU{ - Cla: cla, - Ins: ins, - P1: p1, - P2: p2, - Data: fulldata, - }) - if err != nil { - return nil, err - } - - rmeta := [16]byte{byte(len(response.Data))} - rmac := response.Data[:len(s.iv)] - rdata := response.Data[len(s.iv):] - plainData, err := s.decryptAPDU(rdata) - if err != nil { - return nil, err - } - - if err = s.updateIV(rmeta[:], rdata); err != nil { - return nil, err - } - if !bytes.Equal(s.iv, rmac) { - return nil, fmt.Errorf("invalid MAC in response") - } - - rapdu := &responseAPDU{} - rapdu.deserialize(plainData) - - if rapdu.Sw1 != sw1Ok { - return nil, fmt.Errorf("unexpected response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", cla, ins, rapdu.Sw1, rapdu.Sw2) - } - - return rapdu, nil -} - -// encryptAPDU is an internal method that serializes and encrypts an APDU. -func (s *SecureChannelSession) encryptAPDU(data []byte) ([]byte, error) { - if len(data) > maxPayloadSize { - return nil, fmt.Errorf("payload of %d bytes exceeds maximum of %d", len(data), maxPayloadSize) - } - data = pad(data, 0x80) - - ret := make([]byte, len(data)) - - a, err := aes.NewCipher(s.sessionEncKey) - if err != nil { - return nil, err - } - crypter := cipher.NewCBCEncrypter(a, s.iv) - crypter.CryptBlocks(ret, data) - return ret, nil -} - -// pad applies message padding to a 16 byte boundary. -func pad(data []byte, terminator byte) []byte { - padded := make([]byte, (len(data)/16+1)*16) - copy(padded, data) - padded[len(data)] = terminator - return padded -} - -// decryptAPDU is an internal method that decrypts and deserializes an APDU. -func (s *SecureChannelSession) decryptAPDU(data []byte) ([]byte, error) { - a, err := aes.NewCipher(s.sessionEncKey) - if err != nil { - return nil, err - } - - ret := make([]byte, len(data)) - - crypter := cipher.NewCBCDecrypter(a, s.iv) - crypter.CryptBlocks(ret, data) - return unpad(ret, 0x80) -} - -// unpad strips padding from a message. -func unpad(data []byte, terminator byte) ([]byte, error) { - for i := 1; i <= 16; i++ { - switch data[len(data)-i] { - case 0: - continue - case terminator: - return data[:len(data)-i], nil - default: - return nil, fmt.Errorf("expected end of padding, got %d", data[len(data)-i]) - } - } - return nil, fmt.Errorf("expected end of padding, got 0") -} - -// updateIV is an internal method that updates the initialization vector after -// each message exchanged. -func (s *SecureChannelSession) updateIV(meta, data []byte) error { - data = pad(data, 0) - a, err := aes.NewCipher(s.sessionMacKey) - if err != nil { - return err - } - crypter := cipher.NewCBCEncrypter(a, make([]byte, 16)) - crypter.CryptBlocks(meta, meta) - crypter.CryptBlocks(data, data) - // The first 16 bytes of the last block is the MAC - s.iv = data[len(data)-32 : len(data)-16] - return nil -}

diff --git go-ethereum/cmd/geth/les_test.go celo/cmd/geth/les_test.go index 75f5f128ddea15df7604d5d2beee18092203794a..7521af48c7bce080203457e6d32b6b76d6c8fa47 100644 --- go-ethereum/cmd/geth/les_test.go +++ celo/cmd/geth/les_test.go @@ -65,41 +65,6 @@ g.callRPC(&g.nodeInfo, "admin_nodeInfo") return g.nodeInfo }   -func (g *gethrpc) waitSynced() { - // Check if it's synced now - var result interface{} - g.callRPC(&result, "eth_syncing") - syncing, ok := result.(bool) - if ok && !syncing { - g.geth.Logf("%v already synced", g.name) - return - } - - // Actually wait, subscribe to the event - ch := make(chan interface{}) - sub, err := g.rpc.Subscribe(context.Background(), "eth", ch, "syncing") - if err != nil { - g.geth.Fatalf("%v syncing: %v", g.name, err) - } - defer sub.Unsubscribe() - timeout := time.After(4 * time.Second) - select { - case ev := <-ch: - g.geth.Log("'syncing' event", ev) - syncing, ok := ev.(bool) - if ok && !syncing { - break - } - g.geth.Log("Other 'syncing' event", ev) - case err := <-sub.Err(): - g.geth.Fatalf("%v notification: %v", g.name, err) - break - case <-timeout: - g.geth.Fatalf("%v timeout syncing", g.name) - break - } -} - // ipcEndpoint resolves an IPC endpoint based on a configured value, taking into // account the set data folders as well as the designated platform we're currently // running on. @@ -165,7 +130,9 @@ datadir := initGeth(t) t.Logf("Importing keys to geth") runGeth(t, "--datadir", datadir, "--password", "./testdata/password.txt", "account", "import", "./testdata/key.prv", "--lightkdf").WaitExit() account := "0x02f0d131f1f97aef08aec6e3291b957d9efe7105" - server := startGethWithIpc(t, "lightserver", "--allow-insecure-unlock", "--datadir", datadir, "--password", "./testdata/password.txt", "--unlock", account, "--mine", "--light.serve=100", "--light.maxpeers=1", "--nodiscover", "--nat=extip:127.0.0.1", "--verbosity=4") + server := startGethWithIpc(t, "lightserver", "--allow-insecure-unlock", "--datadir", datadir, "--password", "./testdata/password.txt", + "--unlock", account, "--mine", "--miner.validator", account, "--tx-fee-recipient", account, + "--light.serve=100", "--light.maxpeers=1", "--nodiscover", "--nat=extip:127.0.0.1", "--verbosity=4") return server }

diff --git go-ethereum/cmd/geth/chaincmd.go celo/cmd/geth/chaincmd.go index 12616fbbb66fa9bbdee9a06681c891332fcbb2c6..5c67aca3493ca058a79695d9846ea19b91dd2066 100644 --- go-ethereum/cmd/geth/chaincmd.go +++ celo/cmd/geth/chaincmd.go @@ -38,6 +38,7 @@ "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/node" + "gopkg.in/urfave/cli.v1" )   @@ -65,9 +66,8 @@ Usage: "Dumps genesis block JSON configuration to stdout", ArgsUsage: "", Flags: []cli.Flag{ utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Category: "BLOCKCHAIN COMMANDS", Description: ` @@ -80,6 +80,8 @@ Usage: "Import a blockchain file", ArgsUsage: "<filename> (<filename 2> ... <filename N>) ", Flags: []cli.Flag{ utils.DataDirFlag, + utils.AlfajoresFlag, + utils.BaklavaFlag, utils.CacheFlag, utils.SyncModeFlag, utils.GCModeFlag, @@ -117,6 +119,8 @@ Usage: "Export blockchain into file", ArgsUsage: "<filename> [<blockNumFirst> <blockNumLast>]", Flags: []cli.Flag{ utils.DataDirFlag, + utils.AlfajoresFlag, + utils.BaklavaFlag, utils.CacheFlag, utils.SyncModeFlag, }, @@ -135,6 +139,8 @@ Usage: "Import the preimage database from an RLP stream", ArgsUsage: "<datafile>", Flags: []cli.Flag{ utils.DataDirFlag, + utils.AlfajoresFlag, + utils.BaklavaFlag, utils.CacheFlag, utils.SyncModeFlag, }, @@ -149,6 +155,8 @@ Usage: "Export the preimage database into an RLP stream", ArgsUsage: "<dumpfile>", Flags: []cli.Flag{ utils.DataDirFlag, + utils.AlfajoresFlag, + utils.BaklavaFlag, utils.CacheFlag, utils.SyncModeFlag, }, @@ -163,6 +171,8 @@ Usage: "Dump a specific block from storage", ArgsUsage: "[? <blockHash> | <blockNum>]", Flags: []cli.Flag{ utils.DataDirFlag, + utils.AlfajoresFlag, + utils.BaklavaFlag, utils.CacheFlag, utils.IterativeOutputFlag, utils.ExcludeCodeFlag, @@ -200,7 +210,7 @@ // Open and initialise both full and light databases stack, _ := makeConfigNode(ctx) defer stack.Close()   - for _, name := range []string{"chaindata", "lightchaindata"} { + for _, name := range []string{"chaindata", "lightchaindata", "lightestchaindata"} { chaindb, err := stack.OpenDatabase(name, 0, 0, "", false) if err != nil { utils.Fatalf("Failed to open database: %v", err) @@ -219,7 +229,7 @@ func dumpGenesis(ctx *cli.Context) error { // TODO(rjl493456442) support loading from the custom datadir genesis := utils.MakeGenesis(ctx) if genesis == nil { - genesis = core.DefaultGenesisBlock() + genesis = core.MainnetGenesisBlock() } if err := json.NewEncoder(os.Stdout).Encode(genesis); err != nil { utils.Fatalf("could not encode genesis") @@ -261,18 +271,10 @@ // Import the chain start := time.Now()   var importErr error - - if len(ctx.Args()) == 1 { - if err := utils.ImportChain(chain, ctx.Args().First()); err != nil { + for _, arg := range ctx.Args() { + if err := utils.ImportChain(chain, arg); err != nil { importErr = err - log.Error("Import error", "err", err) - } - } else { - for _, arg := range ctx.Args() { - if err := utils.ImportChain(chain, arg); err != nil { - importErr = err - log.Error("Import error", "file", arg, "err", err) - } + log.Error("Import error", "file", arg, "err", err) } } chain.Stop()

diff --git go-ethereum/cmd/geth/dbcmd.go celo/cmd/geth/dbcmd.go index cc79c8fcfef4414b4c19f20d57cd31844176a1c2..a2ec506275844980cf013ef33c393c4495dac080 100644 --- go-ethereum/cmd/geth/dbcmd.go +++ celo/cmd/geth/dbcmd.go @@ -72,9 +72,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Usage: "Inspect the storage size for each type of data in the database", Description: `This commands iterates the entire database. If the optional 'prefix' and 'start' arguments are provided, then the iteration is limited to the given subset of data.`, @@ -87,9 +86,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, } dbCompactCmd = cli.Command{ @@ -100,9 +98,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, utils.CacheFlag, utils.CacheDatabaseFlag, }, @@ -119,9 +116,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Description: "This command looks up the specified database key from the database.", } @@ -134,9 +130,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Description: `This command deletes the specified database key from the database. WARNING: This is a low-level operation which may cause database corruption!`, @@ -150,9 +145,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Description: `This command sets a given database key to the given value. WARNING: This is a low-level operation which may cause database corruption!`, @@ -166,9 +160,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Description: "This command looks up the specified database key from the database.", } @@ -181,9 +174,8 @@ Flags: []cli.Flag{ utils.DataDirFlag, utils.SyncModeFlag, utils.MainnetFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, }, Description: "This command displays information about the freezer index.", }

diff --git go-ethereum/cmd/geth/config.go celo/cmd/geth/config.go index caac115e7b9a8d702ec31e34b6c99949602126be..3a299bb2ec2e21de371b65fca46287168bfb73e2 100644 --- go-ethereum/cmd/geth/config.go +++ celo/cmd/geth/config.go @@ -25,21 +25,19 @@ "os" "reflect" "unicode"   - "gopkg.in/urfave/cli.v1" - "github.com/ethereum/go-ethereum/accounts/external" "github.com/ethereum/go-ethereum/accounts/keystore" - "github.com/ethereum/go-ethereum/accounts/scwallet" "github.com/ethereum/go-ethereum/accounts/usbwallet" "github.com/ethereum/go-ethereum/cmd/utils" - "github.com/ethereum/go-ethereum/eth/catalyst" "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" + "github.com/naoina/toml" + "gopkg.in/urfave/cli.v1" )   var ( @@ -135,6 +133,7 @@ }   // Apply flags. utils.SetNodeConfig(ctx, &cfg.Node) + utils.SetProxyConfig(ctx, &cfg.Node, &cfg.Eth) stack, err := node.New(&cfg.Node) if err != nil { utils.Fatalf("Failed to create the protocol stack: %v", err) @@ -145,8 +144,11 @@ utils.Fatalf("Failed to set account manager backends: %v", err) }   utils.SetEthConfig(ctx, stack, &cfg.Eth) - if ctx.GlobalIsSet(utils.EthStatsURLFlag.Name) { - cfg.Ethstats.URL = ctx.GlobalString(utils.EthStatsURLFlag.Name) + if ctx.GlobalIsSet(utils.CeloStatsURLFlag.Name) { + cfg.Ethstats.URL = ctx.GlobalString(utils.CeloStatsURLFlag.Name) + } else if ctx.GlobalIsSet(utils.LegacyEthStatsURLFlag.Name) { + cfg.Ethstats.URL = ctx.GlobalString(utils.LegacyEthStatsURLFlag.Name) + log.Warn("The flag --ethstats is deprecated and will be removed in the future, please use --celostats") } applyMetricConfig(ctx, &cfg)   @@ -156,20 +158,10 @@ // makeFullNode loads geth configuration and creates the Ethereum backend. func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) { stack, cfg := makeConfigNode(ctx) - if ctx.GlobalIsSet(utils.OverrideLondonFlag.Name) { - cfg.Eth.OverrideLondon = new(big.Int).SetUint64(ctx.GlobalUint64(utils.OverrideLondonFlag.Name)) - } - backend, eth := utils.RegisterEthService(stack, &cfg.Eth) - - // Configure catalyst. - if ctx.GlobalBool(utils.CatalystFlag.Name) { - if eth == nil { - utils.Fatalf("Catalyst does not work in light client mode.") - } - if err := catalyst.Register(stack, eth); err != nil { - utils.Fatalf("%v", err) - } + if ctx.GlobalIsSet(utils.OverrideEHardforkFlag.Name) { + cfg.Eth.OverrideEHardfork = new(big.Int).SetUint64(ctx.GlobalUint64(utils.OverrideEHardforkFlag.Name)) } + backend, _ := utils.RegisterEthService(stack, &cfg.Eth)   // Configure GraphQL if requested if ctx.GlobalIsSet(utils.GraphQLEnabledFlag.Name) { @@ -312,14 +304,6 @@ if trezorhub, err := usbwallet.NewTrezorHubWithWebUSB(); err != nil { log.Warn(fmt.Sprintf("Failed to start WebUSB Trezor hub, disabling: %v", err)) } else { am.AddBackend(trezorhub) - } - } - if len(conf.SmartCardDaemonPath) > 0 { - // Start a smart card hub - if schub, err := scwallet.NewHub(conf.SmartCardDaemonPath, scwallet.Scheme, keydir); err != nil { - log.Warn(fmt.Sprintf("Failed to start smart card hub, disabling: %v", err)) - } else { - am.AddBackend(schub) } }

diff --git go-ethereum/cmd/geth/consolecmd_test.go celo/cmd/geth/consolecmd_test.go index 5c032a4bcd48802cf06db63a05f7cb66294d0b38..9c04fa72426b82bd77e17e88ca8c0ee8f2a0e604 100644 --- go-ethereum/cmd/geth/consolecmd_test.go +++ celo/cmd/geth/consolecmd_test.go @@ -31,7 +31,7 @@ "github.com/ethereum/go-ethereum/params" )   const ( - ipcAPIs = "admin:1.0 debug:1.0 eth:1.0 ethash:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0" + ipcAPIs = "admin:1.0 debug:1.0 eth:1.0 istanbul:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0" httpAPIs = "eth:1.0 net:1.0 rpc:1.0 web3:1.0" )   @@ -39,11 +39,10 @@ // spawns geth with the given command line args, using a set of flags to minimise // memory and disk IO. If the args don't set --datadir, the // child g gets a temporary data directory. func runMinimalGeth(t *testing.T, args ...string) *testgeth { - // --ropsten to make the 'writing genesis to disk' faster (no accounts) // --networkid=1337 to avoid cache bump // --syncmode=full to avoid allocating fast sync bloom - allArgs := []string{"--ropsten", "--networkid", "1337", "--syncmode=full", "--port", "0", - "--nat", "none", "--nodiscover", "--maxpeers", "0", "--cache", "64"} + allArgs := []string{"--networkid", "1337", "--syncmode=full", "--port", "0", + "--nat", "none", "--nodiscover", "--maxpeers", "0", "--light.maxpeers", "0", "--cache", "64"} return runGeth(t, append(allArgs, args...)...) }   @@ -53,7 +52,7 @@ func TestConsoleWelcome(t *testing.T) { coinbase := "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"   // Start a geth console, make sure it's cleaned up and terminate the console - geth := runMinimalGeth(t, "--miner.etherbase", coinbase, "console") + geth := runMinimalGeth(t, "--etherbase", coinbase, "console")   // Gather all the infos the welcome message needs to contain geth.SetTemplateFunc("goos", func() string { return runtime.GOOS }) @@ -61,15 +60,15 @@ geth.SetTemplateFunc("goarch", func() string { return runtime.GOARCH }) geth.SetTemplateFunc("gover", runtime.Version) geth.SetTemplateFunc("gethver", func() string { return params.VersionWithCommit("", "") }) geth.SetTemplateFunc("niltime", func() string { - return time.Unix(0, 0).Format("Mon Jan 02 2006 15:04:05 GMT-0700 (MST)") + return time.Unix(0x5ea06a00, 0).Format("Mon Jan 02 2006 15:04:05 GMT-0700 (MST)") }) geth.SetTemplateFunc("apis", func() string { return ipcAPIs })   // Verify the actual welcome message to the required template geth.Expect(` -Welcome to the Geth JavaScript console! +Welcome to the Celo JavaScript console!   -instance: Geth/v{{gethver}}/{{goos}}-{{goarch}}/{{gover}} +instance: celo/v{{gethver}}/{{goos}}-{{goarch}}/{{gover}} coinbase: {{.Etherbase}} at block: 0 ({{niltime}}) datadir: {{.Datadir}} @@ -100,7 +99,7 @@ // And HTTP + WS attachment p := trulyRandInt(1024, 65533) // Yeah, sometimes this will fail, sorry :P httpPort = strconv.Itoa(p) wsPort = strconv.Itoa(p + 1) - geth := runMinimalGeth(t, "--miner.etherbase", "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182", + geth := runMinimalGeth(t, "--etherbase", "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182", "--ipcpath", ipc, "--http", "--http.port", httpPort, "--ws", "--ws.port", wsPort) @@ -133,7 +132,7 @@ attach.SetTemplateFunc("gover", runtime.Version) attach.SetTemplateFunc("gethver", func() string { return params.VersionWithCommit("", "") }) attach.SetTemplateFunc("etherbase", func() string { return geth.Etherbase }) attach.SetTemplateFunc("niltime", func() string { - return time.Unix(0, 0).Format("Mon Jan 02 2006 15:04:05 GMT-0700 (MST)") + return time.Unix(0x5ea06a00, 0).Format("Mon Jan 02 2006 15:04:05 GMT-0700 (MST)") }) attach.SetTemplateFunc("ipc", func() bool { return strings.HasPrefix(endpoint, "ipc") }) attach.SetTemplateFunc("datadir", func() string { return geth.Datadir }) @@ -141,9 +140,9 @@ attach.SetTemplateFunc("apis", func() string { return apis })   // Verify the actual welcome message to the required template attach.Expect(` -Welcome to the Geth JavaScript console! +Welcome to the Celo JavaScript console!   -instance: Geth/v{{gethver}}/{{goos}}-{{goarch}}/{{gover}} +instance: celo/v{{gethver}}/{{goos}}-{{goarch}}/{{gover}} coinbase: {{etherbase}} at block: 0 ({{niltime}}){{if ipc}} datadir: {{datadir}}{{end}}

diff --git go-ethereum/cmd/geth/main.go celo/cmd/geth/main.go index af3e7722a6559eb62854aa2291c02edeb886d6d8..e7bdf4c2a3d96f756579bd932609dc15db68d031 100644 --- go-ethereum/cmd/geth/main.go +++ celo/cmd/geth/main.go @@ -18,6 +18,7 @@ // geth is the official command-line client for Ethereum. package main   import ( + "context" "fmt" "os" "sort" @@ -30,20 +31,25 @@ "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/console/prompt" + "github.com/ethereum/go-ethereum/contracts/blockchain_parameters" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth/downloader" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/internal/debug" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/flags" + lesDownloader "github.com/ethereum/go-ethereum/les/downloader" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/rpc" "gopkg.in/urfave/cli.v1" )   const ( - clientIdentifier = "geth" // Client identifier to advertise over the network + clientIdentifier = "celo" // Client identifier to advertise over the network )   var ( @@ -65,16 +71,8 @@ utils.KeyStoreDirFlag, utils.ExternalSignerFlag, utils.NoUSBFlag, utils.USBFlag, - utils.SmartCardDaemonPathFlag, - utils.OverrideLondonFlag, - utils.EthashCacheDirFlag, - utils.EthashCachesInMemoryFlag, - utils.EthashCachesOnDiskFlag, - utils.EthashCachesLockMmapFlag, - utils.EthashDatasetDirFlag, - utils.EthashDatasetsInMemoryFlag, - utils.EthashDatasetsOnDiskFlag, - utils.EthashDatasetsLockMmapFlag, + // utils.SmartCardDaemonPathFlag, + utils.OverrideEHardforkFlag, utils.TxPoolLocalsFlag, utils.TxPoolNoLocalsFlag, utils.TxPoolJournalFlag, @@ -97,11 +95,15 @@ utils.LightEgressFlag, utils.LightMaxPeersFlag, utils.LightNoPruneFlag, utils.LightKDFFlag, + utils.LightGatewayFeeFlag, utils.UltraLightServersFlag, utils.UltraLightFractionFlag, utils.UltraLightOnlyAnnounceFlag, utils.LightNoSyncServeFlag, utils.WhitelistFlag, + utils.EtherbaseFlag, + utils.TxFeeRecipientFlag, + utils.BLSbaseFlag, utils.BloomFilterSizeFlag, utils.CacheFlag, utils.CacheDatabaseFlag, @@ -116,15 +118,10 @@ utils.ListenPortFlag, utils.MaxPeersFlag, utils.MaxPendingPeersFlag, utils.MiningEnabledFlag, - utils.MinerThreadsFlag, - utils.MinerNotifyFlag, - utils.LegacyMinerGasTargetFlag, - utils.MinerGasLimitFlag, - utils.MinerGasPriceFlag, - utils.MinerEtherbaseFlag, + utils.MinerValidatorFlag, + utils.LegacyMinerGasPriceFlag, // switched to gas price flag? utils.MinerExtraDataFlag, - utils.MinerRecommitIntervalFlag, - utils.MinerNoVerifyFlag, + utils.LegacyMinerExtraDataFlag, utils.NATFlag, utils.NoDiscoverFlag, utils.DiscoveryV5Flag, @@ -135,24 +132,38 @@ utils.DNSDiscoveryFlag, utils.MainnetFlag, utils.DeveloperFlag, utils.DeveloperPeriodFlag, - utils.RopstenFlag, - utils.RinkebyFlag, - utils.GoerliFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, utils.VMEnableDebugFlag, utils.NetworkIdFlag, - utils.EthStatsURLFlag, - utils.FakePoWFlag, + utils.CeloStatsURLFlag, + utils.LegacyEthStatsURLFlag, utils.NoCompactionFlag, - utils.GpoBlocksFlag, - utils.GpoPercentileFlag, - utils.GpoMaxGasPriceFlag, - utils.GpoIgnoreGasPriceFlag, - utils.MinerNotifyFullFlag, + // utils.GpoBlocksFlag, + // utils.GpoPercentileFlag, + // utils.GpoMaxGasPriceFlag, + // utils.GpoIgnoreGasPriceFlag, configFileFlag, - utils.CatalystFlag, + utils.LegacyIstanbulRequestTimeoutFlag, + utils.LegacyIstanbulBlockPeriodFlag, + utils.LegacyIstanbulProposerPolicyFlag, + utils.IstanbulReplicaFlag, + utils.AnnounceQueryEnodeGossipPeriodFlag, + utils.AnnounceAggressiveQueryEnodeGossipOnEnablementFlag, + utils.PingIPFromPacketFlag, + utils.UseInMemoryDiscoverTableFlag, + utils.VersionCheckFlag, + utils.ProxyFlag, + utils.ProxyInternalFacingEndpointFlag, + utils.ProxiedValidatorAddressFlag, + utils.ProxiedFlag, + utils.ProxyEnodeURLPairsFlag, + utils.LegacyProxyEnodeURLPairsFlag, + utils.ProxyAllowPrivateIPFlag, }   rpcFlags = []cli.Flag{ + utils.DisableRPCETHCompatibility, utils.HTTPEnabledFlag, utils.HTTPListenAddrFlag, utils.HTTPPortFlag, @@ -163,18 +174,25 @@ utils.GraphQLCORSDomainFlag, utils.GraphQLVirtualHostsFlag, utils.HTTPApiFlag, utils.HTTPPathPrefixFlag, + utils.HTTPRequestReadTimeout, + utils.HTTPRequestWriteTimeout, + utils.HTTPRequestIdleTimeout, utils.WSEnabledFlag, utils.WSListenAddrFlag, + utils.LegacyWSListenAddrFlag, utils.WSPortFlag, + utils.LegacyWSPortFlag, utils.WSApiFlag, + utils.LegacyWSApiFlag, utils.WSAllowedOriginsFlag, + utils.LegacyWSAllowedOriginsFlag, utils.WSPathPrefixFlag, utils.IPCDisabledFlag, utils.IPCPathFlag, utils.InsecureUnlockAllowedFlag, + utils.RPCGlobalGasInflationRateFlag, utils.RPCGlobalGasCapFlag, utils.RPCGlobalTxFeeCapFlag, - utils.AllowUnprotectedTxs, }   metricsFlags = []cli.Flag{ @@ -192,6 +210,7 @@ utils.MetricsEnableInfluxDBV2Flag, utils.MetricsInfluxDBTokenFlag, utils.MetricsInfluxDBBucketFlag, utils.MetricsInfluxDBOrganizationFlag, + utils.MetricsLoadTestCSVFlag, } )   @@ -218,8 +237,6 @@ consoleCommand, attachCommand, javascriptCommand, // See misccmd.go: - makecacheCommand, - makedagCommand, versionCommand, versionCheckCommand, licenseCommand, @@ -262,25 +279,21 @@ // This function should be called before launching devp2p stack. func prepare(ctx *cli.Context) { // If we're running a known preset, log it for convenience. switch { - case ctx.GlobalIsSet(utils.RopstenFlag.Name): - log.Info("Starting Geth on Ropsten testnet...") - - case ctx.GlobalIsSet(utils.RinkebyFlag.Name): - log.Info("Starting Geth on Rinkeby testnet...") - - case ctx.GlobalIsSet(utils.GoerliFlag.Name): - log.Info("Starting Geth on Görli testnet...") + case ctx.GlobalIsSet(utils.BaklavaFlag.Name): + log.Info("Starting Geth on Baklava testnet...")   + case ctx.GlobalIsSet(utils.AlfajoresFlag.Name): + log.Info("Starting Geth on Alfajores testnet...") case ctx.GlobalIsSet(utils.DeveloperFlag.Name): log.Info("Starting Geth in ephemeral dev mode...")   case !ctx.GlobalIsSet(utils.NetworkIdFlag.Name): - log.Info("Starting Geth on Ethereum mainnet...") + log.Info("Starting Geth on Celo mainnet...") } // If we're a full node on mainnet without --cache specified, bump default cache allowance if ctx.GlobalString(utils.SyncModeFlag.Name) != "light" && !ctx.GlobalIsSet(utils.CacheFlag.Name) && !ctx.GlobalIsSet(utils.NetworkIdFlag.Name) { // Make sure we're not on any supported preconfigured testnet either - if !ctx.GlobalIsSet(utils.RopstenFlag.Name) && !ctx.GlobalIsSet(utils.RinkebyFlag.Name) && !ctx.GlobalIsSet(utils.GoerliFlag.Name) && !ctx.GlobalIsSet(utils.DeveloperFlag.Name) { + if !ctx.GlobalIsSet(utils.DeveloperFlag.Name) && !ctx.GlobalIsSet(utils.AlfajoresFlag.Name) && !ctx.GlobalIsSet(utils.BaklavaFlag.Name) { // Nope, we're really on mainnet. Bump that cache up! log.Info("Bumping default cache on mainnet", "provided", ctx.GlobalInt(utils.CacheFlag.Name), "updated", 4096) ctx.GlobalSet(utils.CacheFlag.Name, strconv.Itoa(4096)) @@ -376,19 +389,26 @@ // Spawn a standalone goroutine for status synchronization monitoring, // close the node when synchronization is complete if user required. if ctx.GlobalBool(utils.ExitWhenSyncedFlag.Name) { go func() { - sub := stack.EventMux().Subscribe(downloader.DoneEvent{}) + // Subscribing to both events since les has its own downloader + sub := stack.EventMux().Subscribe(downloader.DoneEvent{}, lesDownloader.DoneEvent{}) defer sub.Unsubscribe() for { event := <-sub.Chan() if event == nil { continue } - done, ok := event.Data.(downloader.DoneEvent) - if !ok { + var latest *types.Header + if done, ok := event.Data.(downloader.DoneEvent); ok { + latest = done.Latest + } + if lesDone, ok := event.Data.(lesDownloader.DoneEvent); ok { + latest = lesDone.Latest + } + if latest == nil { continue } - if timestamp := time.Unix(int64(done.Latest.Time), 0); time.Since(timestamp) < 10*time.Minute { - log.Info("Synchronisation completed", "latestnum", done.Latest.Number, "latesthash", done.Latest.Hash(), + if timestamp := time.Unix(int64(latest.Time), 0); time.Since(timestamp) < 10*time.Minute { + log.Info("Synchronisation completed", "latestnum", latest.Number, "latesthash", latest.Hash(), "age", common.PrettyAge(timestamp)) stack.Close() } @@ -396,24 +416,54 @@ } }() }   + isFullNode := ctx.GlobalString(utils.SyncModeFlag.Name) == "full" || ctx.GlobalString(utils.SyncModeFlag.Name) == "fast" + // Miners and proxies only makes sense if a full node is running + if ctx.GlobalBool(utils.ProxyFlag.Name) || ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name) { + if !isFullNode { + utils.Fatalf("Miners and Proxies must be run as a full node") + } + } + // Replicas only makes sense if we are mining + if ctx.GlobalBool(utils.IstanbulReplicaFlag.Name) { + if !(ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name)) { + utils.Fatalf("Must run a replica with mining enabled or in dev mode.") + } + } + // Start auxiliary services if enabled if ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name) { - // Mining only makes sense if a full Ethereum node is running - if ctx.GlobalString(utils.SyncModeFlag.Name) == "light" { - utils.Fatalf("Light clients do not support mining") + if ctx.GlobalBool(utils.ProxyFlag.Name) { + utils.Fatalf("Proxies can't mine") } ethBackend, ok := backend.(*eth.EthAPIBackend) if !ok { utils.Fatalf("Ethereum service not running: %v", err) } - // Set the gas price to the limits from the CLI and start mining - gasprice := utils.GlobalBig(ctx, utils.MinerGasPriceFlag.Name) - ethBackend.TxPool().SetGasPrice(gasprice) - // start mining - threads := ctx.GlobalInt(utils.MinerThreadsFlag.Name) - if err := ethBackend.StartMining(threads); err != nil { + // // TODO: Handle gas price. + // // Set the gas price to the limits from the CLI and start mining + // // gasprice := utils.GlobalBig(ctx, utils.LegacyMinerGasPriceFlag.Name) // MinerGasPriceFlag + // gasprice := utils.GlobalBig(ctx, utils.MinerGasPriceFlag.Name) + // // Migration from legacy miner gas price to new flag + // if ctx.GlobalIsSet(utils.LegacyMinerGasPriceFlag.Name) && !ctx.GlobalIsSet(utils.MinerGasPriceFlag.Name) { + // gasprice = utils.GlobalBig(ctx, utils.LegacyMinerGasPriceFlag.Name) + // } + // ethBackend.TxPool().SetGasPrice(gasprice) + + if err := ethBackend.StartMining(); err != nil { utils.Fatalf("Failed to start mining: %v", err) } + } + if !ctx.GlobalBool(utils.VersionCheckFlag.Name) { + runnerFactory := func() (vm.EVMRunner, error) { + header := backend.CurrentHeader() + stateDB, _, err := backend.StateAndHeaderByNumberOrHash(context.Background(), rpc.BlockNumberOrHashWithHash(header.Hash(), true)) + if err != nil { + return nil, err + } + return backend.NewEVMRunner(header, stateDB), nil + } + + blockchain_parameters.SpawnCheck(runnerFactory) } }

diff --git go-ethereum/cmd/geth/consolecmd.go celo/cmd/geth/consolecmd.go index f4c25258bd69ee22b4100a1ca1076e461d73cb25..5f2f05c9b21521356d1ef03033f08676768dc139 100644 --- go-ethereum/cmd/geth/consolecmd.go +++ celo/cmd/geth/consolecmd.go @@ -18,7 +18,6 @@ package main   import ( "fmt" - "os" "path/filepath" "strings"   @@ -121,19 +120,10 @@ if ctx.GlobalIsSet(utils.DataDirFlag.Name) { path = ctx.GlobalString(utils.DataDirFlag.Name) } if path != "" { - if ctx.GlobalBool(utils.RopstenFlag.Name) { - // Maintain compatibility with older Geth configurations storing the - // Ropsten database in `testnet` instead of `ropsten`. - legacyPath := filepath.Join(path, "testnet") - if _, err := os.Stat(legacyPath); !os.IsNotExist(err) { - path = legacyPath - } else { - path = filepath.Join(path, "ropsten") - } - } else if ctx.GlobalBool(utils.RinkebyFlag.Name) { - path = filepath.Join(path, "rinkeby") - } else if ctx.GlobalBool(utils.GoerliFlag.Name) { - path = filepath.Join(path, "goerli") + if ctx.GlobalBool(utils.BaklavaFlag.Name) { + path = filepath.Join(path, "baklava") + } else if ctx.GlobalBool(utils.AlfajoresFlag.Name) { + path = filepath.Join(path, "alfajores") } } endpoint = fmt.Sprintf("%s/geth.ipc", path)

diff --git go-ethereum/cmd/geth/usage.go celo/cmd/geth/usage.go index 49036581591fc6277d905a77a0cd77f250512e46..81994d75928c700dd3a9a98e8c7df848d54a1cd6 100644 --- go-ethereum/cmd/geth/usage.go +++ celo/cmd/geth/usage.go @@ -39,20 +39,19 @@ utils.AncientFlag, utils.MinFreeDiskSpaceFlag, utils.KeyStoreDirFlag, utils.USBFlag, - utils.SmartCardDaemonPathFlag, utils.NetworkIdFlag, utils.MainnetFlag, - utils.GoerliFlag, - utils.RinkebyFlag, - utils.RopstenFlag, + utils.BaklavaFlag, + utils.AlfajoresFlag, utils.SyncModeFlag, utils.ExitWhenSyncedFlag, utils.GCModeFlag, utils.TxLookupLimitFlag, - utils.EthStatsURLFlag, + utils.CeloStatsURLFlag, utils.IdentityFlag, utils.LightKDFFlag, utils.WhitelistFlag, + utils.TxFeeRecipientFlag, }, }, { @@ -62,6 +61,7 @@ utils.LightServeFlag, utils.LightIngressFlag, utils.LightEgressFlag, utils.LightMaxPeersFlag, + utils.LightGatewayFeeFlag, utils.UltraLightServersFlag, utils.UltraLightFractionFlag, utils.UltraLightOnlyAnnounceFlag, @@ -77,19 +77,6 @@ utils.DeveloperPeriodFlag, }, }, { - Name: "ETHASH", - Flags: []cli.Flag{ - utils.EthashCacheDirFlag, - utils.EthashCachesInMemoryFlag, - utils.EthashCachesOnDiskFlag, - utils.EthashCachesLockMmapFlag, - utils.EthashDatasetDirFlag, - utils.EthashDatasetsInMemoryFlag, - utils.EthashDatasetsOnDiskFlag, - utils.EthashDatasetsLockMmapFlag, - }, - }, - { Name: "TRANSACTION POOL", Flags: []cli.Flag{ utils.TxPoolLocalsFlag, @@ -140,6 +127,9 @@ utils.HTTPApiFlag, utils.HTTPPathPrefixFlag, utils.HTTPCORSDomainFlag, utils.HTTPVirtualHostsFlag, + utils.HTTPRequestReadTimeout, + utils.HTTPRequestWriteTimeout, + utils.HTTPRequestIdleTimeout, utils.WSEnabledFlag, utils.WSListenAddrFlag, utils.WSPortFlag, @@ -149,9 +139,9 @@ utils.WSAllowedOriginsFlag, utils.GraphQLEnabledFlag, utils.GraphQLCORSDomainFlag, utils.GraphQLVirtualHostsFlag, + utils.RPCGlobalGasInflationRateFlag, utils.RPCGlobalGasCapFlag, utils.RPCGlobalTxFeeCapFlag, - utils.AllowUnprotectedTxs, utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag, @@ -171,30 +161,16 @@ utils.DiscoveryV5Flag, utils.NetrestrictFlag, utils.NodeKeyFileFlag, utils.NodeKeyHexFlag, + utils.PingIPFromPacketFlag, + utils.UseInMemoryDiscoverTableFlag, }, }, { Name: "MINER", Flags: []cli.Flag{ utils.MiningEnabledFlag, - utils.MinerThreadsFlag, - utils.MinerNotifyFlag, - utils.MinerNotifyFullFlag, - utils.MinerGasPriceFlag, - utils.MinerGasLimitFlag, - utils.MinerEtherbaseFlag, + utils.MinerValidatorFlag, utils.MinerExtraDataFlag, - utils.MinerRecommitIntervalFlag, - utils.MinerNoVerifyFlag, - }, - }, - { - Name: "GAS PRICE ORACLE", - Flags: []cli.Flag{ - utils.GpoBlocksFlag, - utils.GpoPercentileFlag, - utils.GpoMaxGasPriceFlag, - utils.GpoIgnoreGasPriceFlag, }, }, { @@ -206,7 +182,6 @@ }, { Name: "LOGGING AND DEBUGGING", Flags: append([]cli.Flag{ - utils.FakePoWFlag, utils.NoCompactionFlag, }, debug.Flags...), }, @@ -215,18 +190,55 @@ Name: "METRICS AND STATS", Flags: metricsFlags, }, { + Name: "ISTANBUL", + Flags: []cli.Flag{ + utils.IstanbulReplicaFlag, + }, + }, + { + Name: "ANNOUNCE", + Flags: []cli.Flag{ + utils.AnnounceQueryEnodeGossipPeriodFlag, + utils.AnnounceAggressiveQueryEnodeGossipOnEnablementFlag, + }, + }, + { + Name: "PROXY", + Flags: []cli.Flag{ + utils.ProxyFlag, + utils.ProxyInternalFacingEndpointFlag, + utils.ProxiedValidatorAddressFlag, + utils.ProxiedFlag, + utils.ProxyEnodeURLPairsFlag, + utils.ProxyAllowPrivateIPFlag, + }, + }, + { Name: "ALIASED (deprecated)", Flags: []cli.Flag{ + utils.EtherbaseFlag, + utils.LegacyMinerGasPriceFlag, + utils.LegacyProxyEnodeURLPairsFlag, + utils.LegacyIstanbulRequestTimeoutFlag, + utils.LegacyIstanbulBlockPeriodFlag, + utils.LegacyIstanbulProposerPolicyFlag, + utils.LegacyEthStatsURLFlag, utils.NoUSBFlag, + utils.LegacyWSListenAddrFlag, + utils.LegacyWSPortFlag, + utils.LegacyWSAllowedOriginsFlag, + utils.LegacyWSApiFlag, + utils.LegacyGraphQLListenAddrFlag, + utils.LegacyGraphQLPortFlag, }, }, { Name: "MISC", Flags: []cli.Flag{ + utils.VersionCheckFlag, utils.SnapshotFlag, utils.BloomFilterSizeFlag, cli.HelpFlag, - utils.CatalystFlag, }, }, }

diff --git go-ethereum/cmd/geth/version_check.go celo/cmd/geth/version_check.go index 5c1f724d6f75f121a44243550331001011e11bee..4a4c56f04b67b749eeb80926ca756a9c13a1d6cf 100644 --- go-ethereum/cmd/geth/version_check.go +++ celo/cmd/geth/version_check.go @@ -114,6 +114,8 @@ func fetch(url string) ([]byte, error) { if filep := strings.TrimPrefix(url, "file://"); filep != url { return ioutil.ReadFile(filep) } + // gosec/G107. This function is called with a node/validator flag, no need to run gosec. + //nolint:gosec res, err := http.Get(url) if err != nil { return nil, err

diff --git go-ethereum/cmd/geth/genesis_test.go celo/cmd/geth/genesis_test.go index 823a92d53024bc15ca02b70e81733eff4968c0a8..66bfaa068af2c1dcc06de6be278617624ed454d2 100644 --- go-ethereum/cmd/geth/genesis_test.go +++ celo/cmd/geth/genesis_test.go @@ -17,60 +17,117 @@ package main   import ( + "fmt" "io/ioutil" "os" "path/filepath" "testing" )   -var customGenesisTests = []struct { - genesis string - query string - result string -}{ - // Genesis file with an empty chain configuration (ensure missing fields work) - { - genesis: `{ - "alloc" : {}, +const ( + registryAddress = "'0x000000000000000000000000000000000000ce10'" + registryCode = "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" +) + +// TestCustomGenesis tests that initializing Geth with a custom genesis block and chain definitions +// work properly. +func TestCustomGenesis(t *testing.T) { + customGenesisTests := []struct { + genesis string + query string + result string + }{ + // Genesis file with an empty chain configuration (ensure missing fields work) + // Note: We add Registry to genesis because it's required for initializing a eth node. + { + genesis: fmt.Sprintf(`{ + "alloc" : { + "000000000000000000000000000000000000ce10" : { + "code": + "%s", + "storage":{"0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103":"47e172F6CfB6c7D01C1574fa3E2Be7CC73269D95"}, + "balance":"0" + } + }, "coinbase" : "0x0000000000000000000000000000000000000000", - "difficulty" : "0x20000", "extraData" : "", - "gasLimit" : "0x2fefd8", - "nonce" : "0x0000000000001338", - "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", - "timestamp" : "0x00", - "config" : {} - }`, - query: "eth.getBlock(0).nonce", - result: "0x0000000000001338", - }, - // Genesis file with specific chain configurations - { - genesis: `{ - "alloc" : {}, + "timestamp" : "0xabcdef", + "config" : { + "istanbul": {} + } + }`, registryCode), + query: "eth.getBlock(0).timestamp", + result: "11259375", + }, + // Genesis file with specific chain configurations + { + genesis: fmt.Sprintf(`{ + "alloc" : { + "000000000000000000000000000000000000ce10" : { + "code": + "%s", + "storage":{"0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103":"47e172F6CfB6c7D01C1574fa3E2Be7CC73269D95"}, + "balance":"0" + } + }, "coinbase" : "0x0000000000000000000000000000000000000000", - "difficulty" : "0x20000", "extraData" : "", - "gasLimit" : "0x2fefd8", - "nonce" : "0x0000000000001339", - "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", - "timestamp" : "0x00", + "timestamp" : "0xabcdf0", "config" : { "homesteadBlock" : 42, "daoForkBlock" : 141, - "daoForkSupport" : true + "daoForkSupport" : true, + "istanbul": {} + } + }`, registryCode), + query: "eth.getBlock(0).timestamp", + result: "11259376", + }, + // Genesis file with an empty chain configuration, and a deployed registry + { + genesis: fmt.Sprintf(`{ + "alloc" : { + "000000000000000000000000000000000000ce10" : { + "code": + "%s", + "storage":{"0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103":"47e172F6CfB6c7D01C1574fa3E2Be7CC73269D95"}, + "balance":"0" + } + }, + "coinbase" : "0x0000000000000000000000000000000000000000", + "extraData" : "", + "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", + "timestamp" : "0xabcdf0", + "config" : { + "istanbul": {} } - }`, - query: "eth.getBlock(0).nonce", - result: "0x0000000000001339", - }, -} + }`, registryCode), + query: "eth.getCode(" + registryAddress + ")", + result: registryCode, + }, + // Genesis file without Registry deployed + { + // nolint:gosimple + genesis: fmt.Sprintf(`{ + "alloc" : {}, + "coinbase" : "0x0000000000000000000000000000000000000000", + "extraData" : "", + "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", + "timestamp" : "0xabcdf0", + "config" : { + "homesteadBlock" : 42, + "daoForkBlock" : 141, + "daoForkSupport" : true, + "istanbul": {} + } + }`), + query: "", // No need, initializing node is supposed to fail + result: "no Registry Smart Contract deployed in genesis", + }, + }   -// Tests that initializing Geth with a custom genesis block and chain definitions -// work properly. -func TestCustomGenesis(t *testing.T) { for i, tt := range customGenesisTests { // Create a temporary data directory to use and inspect later datadir := tmpdir(t) @@ -84,11 +141,25 @@ } runGeth(t, "--datadir", datadir, "init", json).WaitExit()   // Query the custom genesis block - geth := runGeth(t, "--networkid", "1337", "--syncmode=full", "--cache", "16", - "--datadir", datadir, "--maxpeers", "0", "--port", "0", + geth := runGeth(t, "--nousb", "--networkid", "1337", "--syncmode=full", + "--datadir", datadir, "--maxpeers", "0", "--port", "0", "--light.maxpeers", "0", "--nodiscover", "--nat", "none", "--ipcdisable", "--exec", tt.query, "console") geth.ExpectRegexp(tt.result) geth.ExpectExit() } } + +// TestRegistryInGenesis tests that initializing Geth with a default genesis block(mainnet genesis) +// Expects registry contract is deployed. +func TestRegistryInGenesis(t *testing.T) { + query := fmt.Sprintf("eth.getCode(%s)", registryAddress) + + // Query the custom genesis block + geth := runGeth(t, "--maxpeers", "0", "--port", "0", "--light.maxpeers", "0", + "--nodiscover", "--nat", "none", "--ipcdisable", + "--exec", query, "console") + defer geth.Cleanup() + geth.ExpectRegexp(registryCode) + geth.ExpectExit() +}

diff --git go-ethereum/cmd/geth/accountcmd.go celo/cmd/geth/accountcmd.go index 703a937bfcd32a6888b776d18b09deb17ef51ee6..102a2b1d816338f5bb70e9d73875a6ef73e6d514 100644 --- go-ethereum/cmd/geth/accountcmd.go +++ celo/cmd/geth/accountcmd.go @@ -17,18 +17,25 @@ package main   import ( + "encoding/hex" "fmt" "io/ioutil"   "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/accounts/usbwallet" "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" - "gopkg.in/urfave/cli.v1" + cli "gopkg.in/urfave/cli.v1" )   var ( + blsFlag = cli.BoolFlag{ + Name: "bls", + Usage: "Set to specify generation of proof-of-possession of a BLS key.", + } walletCommand = cli.Command{ Name: "wallet", Usage: "Manage Ethereum presale wallets", @@ -101,6 +108,45 @@ Description: ` Print a short summary of all accounts`, }, { + Name: "proof-of-possession", + Usage: "Generate a proof-of-possession for the given account.", + Action: utils.MigrateFlags(accountProofOfPossession), + ArgsUsage: "<signer address> <message>", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.PasswordFileFlag, + utils.LightKDFFlag, + blsFlag, + }, + Description: ` +Print a proof-of-possession signature for the given account. + +Creates a signature over the given message, for example an account address, +with the private key corresponding to a given signer address. The signature +can then be used to prove possession of the signing key, for example to +authorize a the signer to act as a validator in the Celo protocol. +`, + }, + { + Name: "confirm-address", + Usage: "Confirm the entered address appears on the hardware wallet.", + Action: utils.MigrateFlags(accountConfirmHardwareAddress), + ArgsUsage: "<address>", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.PasswordFileFlag, + utils.LightKDFFlag, + }, + Description: ` +Confirms the address exists in the hardware wallet. + +The hardware wallet will not display an address that can't be derived from the stored private key. +`, + }, + + { Name: "new", Usage: "Create a new account", Action: utils.MigrateFlags(accountCreate), @@ -203,6 +249,130 @@ } return nil }   +func printProofOfPossession(account accounts.Account, pop []byte, keyType string, key []byte) { + fmt.Printf("Account {%x}:\n Signature: %s\n %s Public Key: %s\n", account.Address, hex.EncodeToString(pop), keyType, hex.EncodeToString(key)) +} + +func accountProofOfPossession(ctx *cli.Context) error { + if len(ctx.Args()) != 2 { + utils.Fatalf("Please specify the address to prove possession of and the address to sign as proof-of-possession.") + } + + stack, _ := makeConfigNode(ctx) + am := stack.AccountManager() + ks := am.Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore) + + signer := common.HexToAddress(ctx.Args()[0]) + messageString := ctx.Args()[1] + if !common.IsHexAddress(messageString) { + utils.Fatalf("Address to sign is an invalid address") + } + message := common.HexToAddress(messageString) + + var err error + var wallet accounts.Wallet + account := accounts.Account{Address: signer} + foundAccount := false + + for _, wallet = range am.Wallets() { + if wallet.URL().Scheme == keystore.KeyStoreScheme { + if wallet.Contains(account) { + foundAccount = true + break + } + } else if wallet.URL().Scheme == usbwallet.LedgerScheme { + if err := wallet.Open(""); err != nil { + if err != accounts.ErrWalletAlreadyOpen { + utils.Fatalf("Could not open Ledger wallet: %v", err) + } + } else { + defer wallet.Close() + } + + account, err = wallet.Derive(accounts.DefaultBaseDerivationPath, true) + if err != nil { + return err + } + if account.Address == signer { + foundAccount = true + break + } + } + } + if !foundAccount { + utils.Fatalf("Could not find signer account %x", signer) + } + + if wallet.URL().Scheme == keystore.KeyStoreScheme { + account, _ = unlockAccount(ks, signer.String(), 0, utils.MakePasswordList(ctx)) + } + var key []byte + var pop []byte + keyType := "ECDSA" + if ctx.IsSet(blsFlag.Name) { + keyType = "BLS" + key, pop, err = ks.GenerateProofOfPossessionBLS(account, message) + } else { + key, pop, err = wallet.GenerateProofOfPossession(account, message) + } + if err != nil { + return err + } + + printProofOfPossession(account, pop, keyType, key) + + return nil +} + +func accountConfirmHardwareAddress(ctx *cli.Context) error { + if len(ctx.Args()) != 1 { + utils.Fatalf("Please specify the address to confirm on the hardware wallet.") + } + + stack, _ := makeConfigNode(ctx) + am := stack.AccountManager() + + address := common.HexToAddress(ctx.Args()[0]) + + var err error + var wallet accounts.Wallet + account := accounts.Account{Address: address} + foundAccount := false + + for _, wallet = range am.Wallets() { + if wallet.URL().Scheme == usbwallet.LedgerScheme { + if err := wallet.Open(""); err != nil { + if err != accounts.ErrWalletAlreadyOpen { + utils.Fatalf("Could not open Ledger wallet: %v", err) + } + } else { + defer wallet.Close() + } + + account, err = wallet.Derive(accounts.DefaultBaseDerivationPath, true) + if err != nil { + return err + } + if account.Address == address { + foundAccount = true + receivedAddress, err := wallet.ConfirmAddress(accounts.DefaultBaseDerivationPath) + if err != nil { + return err + } + if receivedAddress != address { + utils.Fatalf("Address %x is different in the ledger %x", address, receivedAddress) + } + break + } + } + } + if !foundAccount { + utils.Fatalf("Could not find account %x", account) + } + + return nil +} + // tries unlocking the specified account a few times. func unlockAccount(ks *keystore.KeyStore, address string, i int, passwords []string) (accounts.Account, string) { account, err := utils.MakeAddress(ks, address) @@ -270,7 +440,7 @@ } utils.SetNodeConfig(ctx, &cfg.Node) keydir, err := cfg.Node.KeyDirConfig() if err != nil { - utils.Fatalf("Failed to read configuration: %v", err) + utils.Fatalf("Failed get keystore dir: %v", err) } scryptN := keystore.StandardScryptN scryptP := keystore.StandardScryptP